#  server-sdk-go

**Repository Path**: wfchat/server-sdk-go

## Basic Information

- **Project Name**:  server-sdk-go
- **Description**: golang语言的野火server sdk
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: main
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-03-04
- **Last Updated**: 2026-03-04

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 野火IM Server SDK for Go

野火IM Server SDK的Go语言实现，提供与Java版本SDK相同的功能，包括用户管理、群组管理、消息管理、频道管理、机器人服务等功能。

## 特性

- 完整的Admin API支持（用户、群组、消息、聊天室、频道、敏感词、会议、设备等）
- Robot API支持（机器人消息发送、群组管理、用户信息获取、朋友圈等）
- Channel API支持（频道消息发送、订阅管理、用户信息获取等）
- Mesh API支持（多域互联服务，跨域用户、群组、消息管理）
- 支持多种消息类型（文本、图片、语音、视频、文件、位置、链接、名片、富通知等）
- 流式文本消息支持（AI生成内容）
- 完整的错误码定义
- HTTP连接池和请求重试机制
- 请求签名验证

## 安装

```bash
go get github.com/wildfirechat/server-sdk-go
```

## 快速开始

### 1. 初始化SDK

```go
package main

import (
    wfc "github.com/wildfirechat/server-sdk-go"
)

func main() {
    // 初始化Admin SDK
    // 参数：IM服务器管理地址、管理员密钥
    wfc.InitAdmin("http://localhost:18080", "123456")
}
```

### 2. 用户管理

```go
package main

import (
    "fmt"
    wfc "github.com/wildfirechat/server-sdk-go"
    "github.com/wildfirechat/server-sdk-go/pojos"
)

func main() {
    wfc.InitAdmin("http://localhost:18080", "123456")
    
    userAdmin := wfc.NewUserAdmin()
    
    // 创建用户
    userInfo := pojos.InputOutputUserInfo{
        UserId:      "user123",
        Name:        "testuser",
        Mobile:      "13800138000",
        DisplayName: "测试用户",
    }
    result, err := userAdmin.CreateUser(userInfo)
    if err != nil {
        panic(err)
    }
    if result.IsSuccess() {
        fmt.Printf("创建用户成功: %s\n", result.Result.UserId)
    }
    
    // 获取用户信息
    userResult, err := userAdmin.GetUserByUserId("user123")
    if err != nil {
        panic(err)
    }
    fmt.Printf("用户信息: %+v\n", userResult.Result)
    
    // 获取用户Token
    tokenResult, err := userAdmin.GetUserToken("user123", "client1", 2) // 2 = Android平台
    if err != nil {
        panic(err)
    }
    fmt.Printf("用户Token: %s\n", tokenResult.Result.Token)
    
    // 封禁用户
    _, err = userAdmin.UpdateUserBlockStatus("user123", 2) // 2 = 封禁
    if err != nil {
        panic(err)
    }
    
    // 解封用户
    _, err = userAdmin.UpdateUserBlockStatus("user123", 0) // 0 = 正常
    if err != nil {
        panic(err)
    }
}
```

### 3. 群组管理

```go
package main

import (
    "fmt"
    wfc "github.com/wildfirechat/server-sdk-go"
    "github.com/wildfirechat/server-sdk-go/pojos"
)

func main() {
    wfc.InitAdmin("http://localhost:18080", "123456")
    
    groupAdmin := wfc.NewGroupAdmin()
    
    // 创建群组
    groupInfo := pojos.PojoGroupInfo{
        TargetId: "group123",
        Owner:    "user1",
        Name:     "测试群组",
        Type:     2, // 普通群组
        Portrait: "http://example.com/portrait.jpg",
        Extra:    `{"welcome":"欢迎加入群组"}`,
    }
    
    members := []pojos.PojoGroupMember{
        {MemberId: "user1"},
        {MemberId: "user2"},
        {MemberId: "user3"},
    }
    
    result, err := groupAdmin.CreateGroup("user1", groupInfo, members, "", nil, nil)
    if err != nil {
        panic(err)
    }
    fmt.Printf("创建群组成功: %s\n", result.Result.GroupId)
    
    // 获取群组信息
    groupResult, err := groupAdmin.GetGroupInfo("group123")
    if err != nil {
        panic(err)
    }
    fmt.Printf("群组信息: %+v\n", groupResult.Result)
    
    // 添加群组成员
    newMembers := []pojos.PojoGroupMember{
        {MemberId: "user4", Alias: "用户4"},
    }
    _, err = groupAdmin.AddGroupMembers("user1", "group123", newMembers, "", nil, nil)
    if err != nil {
        panic(err)
    }
    
    // 踢出群组成员
    _, err = groupAdmin.KickoffGroupMembers("user1", "group123", []string{"user3"}, nil, nil)
    if err != nil {
        panic(err)
    }
    
    // 解散群组
    _, err = groupAdmin.DismissGroup("user1", "group123", nil, nil)
    if err != nil {
        panic(err)
    }
}
```

### 4. 发送消息

```go
package main

import (
    "fmt"
    wfc "github.com/wildfirechat/server-sdk-go"
    "github.com/wildfirechat/server-sdk-go/messagecontent"
    "github.com/wildfirechat/server-sdk-go/pojos"
)

func main() {
    wfc.InitAdmin("http://localhost:18080", "123456")
    
    messageAdmin := wfc.NewMessageAdmin()
    
    // 发送文本消息
    conversation := pojos.Conversation{
        Target: "user2",  // 接收者用户ID
        Type:   0,        // 0 = 单聊, 1 = 群组, 2 = 聊天室
        Line:   0,        // 会话线路
    }
    
    textMessage := messagecontent.NewTextMessageContent("Hello, 这是一条测试消息!")
    payload := textMessage.Encode()
    
    result, err := messageAdmin.SendMessage("user1", conversation, *payload)
    if err != nil {
        panic(err)
    }
    fmt.Printf("消息发送成功, 消息UID: %d\n", result.Result.MessageUid)
    
    // 发送图片消息
    imageMessage := messagecontent.NewImageMessageContent()
    imageMessage.RemoteMediaUrl = "https://example.com/image.jpg"
    // imageMessage.ThumbnailBytes = thumbnailBytes // 缩略图数据
    payload = imageMessage.Encode()
    
    result, err = messageAdmin.SendMessage("user1", conversation, *payload)
    if err != nil {
        panic(err)
    }
    
    // 发送富通知消息
    richNotification := messagecontent.NewRichNotificationMessageContent(
        "订单通知",
        "您的订单已发货",
        "https://example.com/order/123",
    ).Remark("如有问题请联系客服").
        AddItem("订单号", "123456", "#173177").
        AddItem("快递公司", "顺丰速运", "#173177").
        AddItem("运单号", "SF123456789", "#173177")
    
    payload = richNotification.Encode()
    result, err = messageAdmin.SendMessage("user1", conversation, *payload)
    if err != nil {
        panic(err)
    }
    
    // 撤回消息
    _, err = messageAdmin.RecallMessage("user1", result.Result.MessageUid)
    if err != nil {
        panic(err)
    }
    
    // 群发消息
    receivers := []string{"user2", "user3", "user4"}
    multicastResult, err := messageAdmin.MulticastMessage("user1", receivers, 0, *payload)
    if err != nil {
        panic(err)
    }
    fmt.Printf("群发消息成功, 消息UID: %d\n", multicastResult.Result.MessageUid)
}
```

### 5. 机器人服务

```go
package main

import (
    "fmt"
    wfc "github.com/wildfirechat/server-sdk-go"
    "github.com/wildfirechat/server-sdk-go/pojos"
)

func main() {
    // 初始化RobotService
    // 参数：IM服务器公开地址、机器人ID、机器人密钥
    robotService := wfc.NewRobotService("http://localhost", "robot1", "123456")
    defer robotService.Close()
    
    // 获取机器人资料
    profile, err := robotService.GetProfile()
    if err != nil {
        panic(err)
    }
    fmt.Printf("机器人资料: %+v\n", profile.Result)
    
    // 设置回调地址
    _, err = robotService.SetCallback("http://your-server.com/robot/callback")
    if err != nil {
        panic(err)
    }
    
    // 发送消息
    conversation := pojos.Conversation{
        Target: "user1",
        Type:   0,
    }
    payload := pojos.MessagePayload{
        Type:              1,
        SearchableContent: "Hello from robot!",
    }
    
    result, err := robotService.SendMessage("robot1", conversation, payload)
    if err != nil {
        panic(err)
    }
    fmt.Printf("机器人消息发送成功, 消息UID: %d\n", result.Result.MessageUid)
    
    // 创建群组（机器人作为群主）
    groupInfo := pojos.PojoGroupInfo{
        TargetId: "robot_group_123",
        Name:     "机器人创建的群组",
        Type:     2,
    }
    members := []pojos.PojoGroupMember{
        {MemberId: "user1"},
        {MemberId: "user2"},
    }
    
    groupResult, err := robotService.CreateGroup(groupInfo, members, "", nil, nil)
    if err != nil {
        panic(err)
    }
    fmt.Printf("机器人创建群组成功: %s\n", groupResult.Result.GroupId)
}
```

### 6. 频道管理

```go
package main

import (
    "fmt"
    wfc "github.com/wildfirechat/server-sdk-go"
    "github.com/wildfirechat/server-sdk-go/pojos"
)

func main() {
    wfc.InitAdmin("http://localhost:18080", "123456")
    
    channelAdmin := wfc.NewChannelAdmin()
    
    // 创建频道
    input := pojos.InputCreateChannel{
        Name:     "测试频道",
        Owner:    "user1",
        Portrait: "http://example.com/channel.png",
        Extra:    `{"description":"这是一个测试频道"}`,
    }
    
    result, err := channelAdmin.CreateChannel(input)
    if err != nil {
        panic(err)
    }
    fmt.Printf("创建频道成功, 频道ID: %s\n", result.Result.TargetId)
    
    // 获取频道信息
    channelInfo, err := channelAdmin.GetChannelInfo(result.Result.TargetId)
    if err != nil {
        panic(err)
    }
    fmt.Printf("频道信息: %+v\n", channelInfo.Result)
    
    // 用户关注频道
    _, err = channelAdmin.SubscribeChannel(result.Result.TargetId, "user1")
    if err != nil {
        panic(err)
    }
    
    // 检查用户是否已关注频道
    isSubscribed, err := channelAdmin.IsUserSubscribedChannel("user1", result.Result.TargetId)
    if err != nil {
        panic(err)
    }
    fmt.Printf("用户是否已关注频道: %v\n", isSubscribed.Result.Value)
}
```

## 消息类型支持

SDK支持以下消息类型：

| 消息类型 | 说明 |
|---------|------|
| TextMessageContent | 文本消息 |
| ImageMessageContent | 图片消息 |
| SoundMessageContent | 语音消息 |
| VideoMessageContent | 视频消息 |
| LocationMessageContent | 位置消息 |
| FileMessageContent | 文件消息 |
| StickerMessageContent | 动态表情消息 |
| LinkMessageContent | 链接消息 |
| CardMessageContent | 名片消息（用户/群组/频道/聊天室） |
| TipNotificationMessageContent | 提醒消息（小灰条） |
| RecallMessageContent | 撤回消息 |
| RichNotificationMessageContent | 富通知消息（类似微信模板消息） |
| StreamTextGeneratingMessageContent | 流式文本生成中（AI消息） |
| StreamTextGeneratedMessageContent | 流式文本生成完成（AI消息） |

## 平台常量

```go
const (
    Platform_iOS     = 1
    Platform_Android = 2
    Platform_Windows = 3
    Platform_OSX     = 4
    Platform_WEB     = 5
    Platform_WX      = 6
)
```

## 会话类型常量

```go
const (
    ConversationType_Private  = 0 // 单聊
    ConversationType_Group    = 1 // 群组
    ConversationType_Chatroom = 2 // 聊天室
    ConversationType_Channel  = 3 // 频道
)
```

## 错误码

SDK定义了与野火IM服务器一致的错误码，详见 `common/errorcode.go`。

常用错误码：

| 错误码 | 说明 |
|-------|------|
| ERROR_CODE_SUCCESS (0) | 成功 |
| ERROR_CODE_AUTH_FAILURE (244) | 鉴权失败，请检查密钥 |
| ERROR_CODE_SIGN_EXPIRED (243) | 签名过期，请检查服务器时间 |
| ERROR_CODE_NOT_EXIST (253) | 用户/群组/频道不存在 |
| ERROR_CODE_ALREADY_FRIENDS (23) | 已经是好友 |
| ERROR_CODE_GROUP_ALREADY_EXIST (11) | 群组已存在 |

## 测试

SDK包含完整的测试程序，参考了Java版本的Main.java：

```bash
# 使用默认配置运行测试
go run main.go

# 使用自定义配置运行测试
go run main.go http://192.168.1.80:18080 123456 http://192.168.1.80 false false

# 参数说明：
# 参数1: Admin URL (管理接口地址)
# 参数2: Admin Secret (管理员密钥)
# 参数3: IM URL (IM服务公开地址，机器人和频道使用)
# 参数4: Commercial Server (是否商业版 true/false)
# 参数5: Advance VoIP (是否启用高级音视频 true/false)
```

## API文档

### Admin 管理类

- `UserAdmin` - 用户管理
- `GroupAdmin` - 群组管理
- `MessageAdmin` - 消息管理
- `RelationAdmin` - 好友关系管理
- `ChannelAdmin` - 频道管理
- `ChatroomAdmin` - 聊天室管理
- `ConferenceAdmin` - 会议管理
- `SensitiveAdmin` - 敏感词管理
- `GeneralAdmin` - 通用设置管理
- `MeshAdmin` - Mesh多域互联管理

### 服务类

- `RobotService` - 机器人服务
- `ChannelServiceApi` - 频道服务API

## 注意事项

1. **初始化顺序**：使用Admin API前必须先调用 `wfc.InitAdmin()` 初始化
2. **机器人服务**：RobotService使用IM服务器的公开端口（默认80），不是Admin端口（18080）
3. **频道服务**：ChannelServiceApi使用IM服务器的公开端口（默认80），需要频道密钥
4. **时间同步**：服务器时间必须与IM服务器时间同步，否则会导致签名过期错误
5. **商业版功能**：部分功能（设备管理、在线用户统计、会议高级功能、频道、聊天室、敏感词）需要商业版服务器支持
6. **Mesh功能**：多域互联功能需要专业版服务器支持

## 许可证

本项目遵循野火IM的开源许可证。

## 相关链接

- [野火IM官网](https://www.wildfirechat.cn)
- [野火IM文档](https://docs.wildfirechat.cn)
- [野火IM GitHub](https://github.com/wildfirechat)