更新版本号和release note

同步专业版server sdk添加获取用户未读数接口
优化文件上传的认证
2026-06-13 10:18:18 +08:00 · 2026-06-13 10:13:19 +08:00 · 2026-06-08 12:07:38 +08:00 · 2026-06-05 15:29:25 +08:00 · 2026-05-18 20:22:31 +08:00 · 2026-05-18 15:53:17 +08:00
279 changed files with 16845 additions and 1468 deletions
@@ -7,9 +7,9 @@
 * 性能强大，专业版IM服务支持百万在线和集群部署，业内顶尖性能水平，详情参考野火性能报告。
 * 部署运维简单，依赖服务少，稍加配置一键启动。
 * 安全加密。网络连接AES加密。客户端数据库SqlCipher加密。安全无小事。
-* 全平台客户端，支持Android、iOS、Web、小程序、UniApp、Flutter、Windows、Mac OS、Linux等所有常见平台。
+* 全平台客户端，支持Android、iOS、鸿蒙、Web、小程序、UniApp、Flutter、Windows、Mac OS、Linux等所有常见平台。
 * 四端同时在线（移动端，pc端，web端和小程序端），数据和状态多端完美同步。
-* 支持国产化。支持国产化操作系统、国产化芯片和国产操作系统。支持国密加密。
+* 支持国产化。支持国产化操作系统、国产化芯片和国产数据库。支持国密加密。
 * 客户端使用微信[mars](https://github.com/tencent/mars)连接库，野火IM可能是最适应中国网络国情的即时通讯服务。
 * 支持加速点加速，即可用于全球应用，也可用于政企内外双网复杂的网络环境。
 * 支持阅读回执和在线状态功能，适用于办公环境。
@@ -22,34 +22,37 @@
 * API丰富，方便与其它服务系统的对接。
 * 拥有机器人和公众号功能，免费的频道（公众号）管理后台。
 * 超级群组功能，可以支持万人大群。
+* 支持多个IM服务组网互通，打破孤岛，适用于集团公司下多个分公司互联互通。
 * 社区版IM服务和移动端免费商用，可以免费构建出完备的移动互联网应用。
 * 收费项目非常便宜，野火独有的试用模式，可以先部署到客户环境试用6个月，试用满意后再购买，避免上当受骗。
-* 技术支持专业和高效，核心研发人员及时处理issue和论坛回复。
+* 技术支持专业高效，***核心研发***及时处理issue和工单，能最快解决用户的技术难题。技术支持不收费，让客户顺利使用是我们最大的愿望。

 ## 野火开源项目
 主要包括以下项目：

-| [GitHub仓库](https://github.com/wildfirechat)      | [码云仓库](https://gitee.com/wfchat)        | 说明                                                                                      
-| ------------------------------------------------------------ | ----------------------------------------------------- | --------------------------------------------------------------------------
-| [im-server](https://github.com/wildfirechat/im-server)       | [im-server](https://gitee.com/wfchat/im-server)          | 野火社区版IM服务，野火IM的核心服务，处理所有IM相关业务。  |
-| [app-server](https://github.com/wildfirechat/app-server)     | [app-server](https://gitee.com/wfchat/app-server)     | Demo应用服务，模拟客户的应用服登陆处理逻辑及部分二次开发示例。 |
-| [robot_server](https://github.com/wildfirechat/robot_server) | [robot_server](https://gitee.com/wfchat/robot_server) | 机器人服务，演示野火机器人对接其它系统的方法。 |
-| [push_server](https://github.com/wildfirechat/push_server)   | [push_server](https://gitee.com/wfchat/push_server)   | 推送服务器，可以对接所有的系统厂商推送服务或者第三方推送服务。 |
-| [wf-minio](https://github.com/wildfirechat/WF-minio)   | [wf-minio](https://gitee.com/wfchat/WF-minio)   | 私有对象存储服务，用来支持野火IM专业版的文件存储。 |
-| [wf-janus](https://github.com/wildfirechat/wf-janus  )   | [wf-janus](https://gitee.com/wfchat/wf-janus  )   | 高级音视频媒体服务。 |
-| [open-platform](https://github.com/wildfirechat/open-platform)   | [open-platform](https://gitee.com/wfchat/open-platform)   | 野火开放平台服务。  |
-| [daily-report](https://github.com/wildfirechat/daily-report)   | [daily-report](https://github.com/wildfirechat/daily-report)   | 野火开放平台日报 demo服务。 |
-| [channel-platform](https://github.com/wildfirechat/channel-platform)   | [channel-platform](https://gitee.com/wfchat/channel-platform)   | 野火频道(公众号)平台服务。  |
-| [organization-platform](https://github.com/wildfirechat/organization-platform)   | [organization-platform](https://gitee.com/wfchat/organization-platform)   | 野火组织通讯录服务。  |
-| [android-chat](https://github.com/wildfirechat/android-chat) | [android-chat](https://gitee.com/wfchat/android-chat) | 野火IM Android SDK源码和App源码。 |
-| [ios-chat](https://github.com/wildfirechat/ios-chat)         | [ios-chat](https://gitee.com/wfchat/ios-chat)         | 野火IM iOS SDK源码和App源码。|
-| [pc-chat](https://github.com/wildfirechat/vue-pc-chat)       | [pc-chat](https://gitee.com/wfchat/vue-pc-chat)       | 基于[Electron](https://electronjs.org/)的PC 端，支持Windows、Mac、Linux（包括国产化linux系统和CPU）。   |
-| [web-chat](https://github.com/wildfirechat/vue-chat)         | [web-chat](https://gitee.com/wfchat/vue-chat)         | 野火IM Web 端, [体验地址](https://web.wildfirechat.cn)。  |
-| [wx-chat](https://github.com/wildfirechat/wx-chat)           | [wx-chat](https://gitee.com/wfchat/wx-chat)           | 小程序平台的Demo(支持微信、百度、阿里、字节、QQ 等小程序平台)。  |
-| [uni-chat](https://github.com/wildfirechat/uni-chat)           | [uni-chat](https://gitee.com/wfchat/uni-chat)           | UniApp平台移动端应用(使用原生插件)。   |
-| [uni-wfc-client](https://github.com/wildfirechat/uni-wfc-client)           | [uni-wfc-client](https://gitee.com/wfchat/uni-wfc-client)           | UniApp平台原生插件。已[商店](https://ext.dcloud.net.cn/plugin?id=7895)上架   |
-| [wfc_flutter_plugins](https://github.com/wildfirechat/wfc_flutter_plugins)           | [flutter_imclient](https://gitee.com/wfchat/wfc_flutter_plugins)           | Flutter平台原生插件，支持IM和音视频通话。   |
-| [docs](https://github.com/wildfirechat/docs)                 | [docs](https://gitee.com/wfchat/docs)                 | 野火IM相关文档，包含设计、概念、开发、使用说明，[在线查看](https://docs.wildfirechat.cn/)。 |
+| [GitHub仓库](https://github.com/wildfirechat)                                    | [码云仓库](https://gitee.com/wfchat)                                        | 说明                                                                                      
+|--------------------------------------------------------------------------------|-------------------------------------------------------------------------| --------------------------------------------------------------------------
+| [im-server](https://github.com/wildfirechat/im-server)                         | [im-server](https://gitee.com/wfchat/im-server)                         | 野火社区版IM服务，野火IM的核心服务，处理所有IM相关业务。  |
+| [app-server](https://github.com/wildfirechat/app-server)                       | [app-server](https://gitee.com/wfchat/app-server)                       | Demo应用服务，模拟客户的应用服登陆处理逻辑及部分二次开发示例。 |
+| [robot_server](https://github.com/wildfirechat/robot_server)                   | [robot_server](https://gitee.com/wfchat/robot_server)                   | 机器人服务，演示野火机器人对接其它系统的方法。 |
+| [push_server](https://github.com/wildfirechat/push_server)                     | [push_server](https://gitee.com/wfchat/push_server)                     | 推送服务器，可以对接所有的系统厂商推送服务或者第三方推送服务。 |
+| [wf-minio](https://github.com/wildfirechat/WF-minio)                           | [wf-minio](https://gitee.com/wfchat/WF-minio)                           | 私有对象存储服务，用来支持野火IM专业版的文件存储。 |
+| [wf-janus](https://github.com/wildfirechat/wf-janus  )                         | [wf-janus](https://gitee.com/wfchat/wf-janus  )                         | 高级音视频媒体服务。 |
+| [open-platform](https://github.com/wildfirechat/open-platform)                 | [open-platform](https://gitee.com/wfchat/open-platform)                 | 野火开放平台服务。  |
+| [daily-report](https://github.com/wildfirechat/daily-report)                   | [daily-report](https://github.com/wildfirechat/daily-report)            | 野火开放平台日报 demo服务。 |
+| [channel-platform](https://github.com/wildfirechat/channel-platform)           | [channel-platform](https://gitee.com/wfchat/channel-platform)           | 野火频道(公众号)平台服务。  |
+| [organization-platform](https://github.com/wildfirechat/organization-platform) | [organization-platform](https://gitee.com/wfchat/organization-platform) | 野火组织通讯录服务。  |
+| [archive-server](https://github.com/wildfirechat/archive-server)               | [archive-server](https://gitee.com/wfchat/archive-server)               | 野火组织通讯录服务。  |
+| [android-chat](https://github.com/wildfirechat/android-chat)                   | [android-chat](https://gitee.com/wfchat/android-chat)                   | 野火IM Android SDK源码和App源码。 |
+| [ios-chat](https://github.com/wildfirechat/ios-chat)                           | [ios-chat](https://gitee.com/wfchat/ios-chat)                           | 野火IM iOS SDK源码和App源码。|
+| [pc-chat(electron)](https://github.com/wildfirechat/vue-pc-chat)               | [pc-chat(electron)](https://gitee.com/wfchat/vue-pc-chat)               | 基于[Electron](https://electronjs.org/)开发的PC 端                   |                         |
+| [pc-chat(Qt)](https://github.com/wildfirechat/qt-pc-chat)                      | [pc-chat(Qt)](https://gitee.com/wfchat/qt-pc-chat)                      | 基于Qt开发的PC 端                   |                         |
+| [web-chat](https://github.com/wildfirechat/vue-chat)                           | [web-chat](https://gitee.com/wfchat/vue-chat)                           | 野火IM Web 端, [体验地址](https://web.wildfirechat.cn)。  |
+| [wx-chat](https://github.com/wildfirechat/wx-chat)                             | [wx-chat](https://gitee.com/wfchat/wx-chat)                             | 小程序平台的Demo(支持微信、百度、阿里、字节、QQ 等小程序平台)。  |
+| [uni-chat](https://github.com/wildfirechat/uni-chat)                           | [uni-chat](https://gitee.com/wfchat/uni-chat)                           | UniApp平台移动端应用(使用原生插件)。   |
+| [uni-wfc-client](https://github.com/wildfirechat/uni-wfc-client)               | [uni-wfc-client](https://gitee.com/wfchat/uni-wfc-client)               | UniApp平台原生插件。已[商店](https://ext.dcloud.net.cn/plugin?id=7895)上架   |
+| [flutter-chat](https://github.com/wildfirechat/flutter-chat)                   | [flutter-chat](https://gitee.com/wfchat/flutter-chat)                   | Flutter平台原生插件，支持IM和音视频通话。   |
+| [docs](https://github.com/wildfirechat/docs)                                   | [docs](https://gitee.com/wfchat/docs)                                   | 野火IM相关文档，包含设计、概念、开发、使用说明，[在线查看](https://docs.wildfirechat.cn/)。 |

 ## 野火开发文档
 [在线文档](https://docs.wildfirechat.cn/)
@@ -119,6 +122,19 @@ mvn clean package

 修改之后运行编译命令```mvn clean package```，rpm包生成在```distribution/target```目录下。

+## Epoll
+在linux系统中打开Epoll开关可以提高性能，默认软件包内打包的是x86_64的epoll native sdk。如果是arm64的机器，可以把[broker pom](./broker/pom.xml)文件中修改如下：
+```xml
+<dependency>
+    <groupId>io.netty</groupId>
+    <artifactId>netty-transport-native-epoll</artifactId>
+    <version>${netty.version}</version>
+<!--    <classifier>linux-x86_64</classifier>-->
+    <classifier>linux-aarch_64</classifier>
+</dependency>
+```
+然后重新打包。专业版IM服务软件包中有arm64架构的sdk，可以直接替换。epoll只支持x86_64和arm64两个架构，其他架构不要把epoll开关打开。
+
 ## 升级说明
 1. 从0.42 版本增加了群成员数限制，默认为2000。如果您从之前的版本升级到这个版本或以后，需要注意到群成员数的限制。升级之后超出限制的群不受影响，但不能继续加人，如果您想修改默认值，可以在升级版本之后，修改t_setting表，把默认的大小改为您期望的人数。另外修改t_group表，把已经存在的群组max_member_count改成您期望的，然后重启。
 2. 0.50版本添加了是否允许客户端发送群操作通知的配置。如果您在客户端自定义群通知，需要在服务器端配置允许，没有使用自定义群操作通知的不受影响。***
@@ -143,6 +159,17 @@ mvn clean package
 ## 服务对象
 因为野火的使用范围比较广，难免被一些不法分子利用，国内反诈反赌力度很大，所以国内多地警方都跟我们都有过联系。***为了预防我们的产品被用于非法目的，试用及购买只能支持境内法人单位，不接受个人或者境外团体。如果我们发现产品被用于非法目的，我们会立即停止技术支持服务并且报警和配合警方调查。请用于非法目的用户绕行！***

+## 群的性能问题
+群的大小和性能不是线性相关的，而是O(N²)的关系，这是群的特性决定的。所以社区版IM服务很难支持很大的群人数，我们建议最大群不要超过500人，像微信的群大小一样。修改方法是修改数据库中```t_settings```表中的群最大人数。
+
+如果是专业版IM服务，普通群性能会有些加强，但也不会提高太多，所以我们就开发了超级群，可以支持上万群成员。关于超级群，请参考[野火超级群组](https://mp.weixin.qq.com/s/ov5ZiaEIUZuvgFBXOrcjbg)。现有客户有接近10W的群组成员能够流畅稳定地运行。
+
+## 网络问题
+如果是自建机房或者私有网络，可能会有跨运营商瓶颈，详情请参考[《从野火 IM 的网络踩坑经历，聊聊跨运营商访问的那些坑》](https://mp.weixin.qq.com/s/Pa8b93oMk58fjMgwtwmePQ)。
+
+## 常见问题
+请参考文档[常见问题](https://docs.wildfirechat.cn/faq/server.html)
+
 ## 应用截图
 登录界面

@@ -0,0 +1,114 @@
+import java.io.*;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.util.Scanner;
+
+/**
+ * 此工具为验证IM服务管理密钥是否正确的工具。
+ * 通过手机号查询 Wildfire IM 用户信息，如果能够返回正确信息或者未找到表示密钥正确。
+ *
+ * 编译：放到IM服务运行服务器上，执行 javac VerifyAdminSecretTool.java  编译得到 VerifyAdminSecretTool.class，
+ * 用法：执行 java VerifyAdminSecretTool 按提示输入 IM 服务地址、管理员密钥、电话号码。
+ * 程序会调用 /admin/user/get_info 接口并打印返回的 JSON。
+ */
+public class VerifyAdminSecretTool {
+
+    private static final SecureRandom RANDOM = new SecureRandom();
+
+    public static void main(String[] args) throws Exception {
+        Scanner scanner = new Scanner(System.in);
+
+        System.out.print("请输入 IM 服务地址（如 http://192.168.1.100:18080）: ");
+        String serverUrl = scanner.nextLine().trim();
+
+        System.out.print("请输入管理员密钥（admin secret）: ");
+        String secret = scanner.nextLine().trim();
+
+        System.out.print("请输入电话号码: ");
+        String mobile = scanner.nextLine().trim();
+
+        scanner.close();
+
+        if (serverUrl.isEmpty() || secret.isEmpty() || mobile.isEmpty()) {
+            System.err.println("错误：服务地址、密钥和电话号码均不能为空");
+            System.exit(1);
+        }
+
+        // 构建请求 URL（去掉末尾可能的 /）
+        if (serverUrl.endsWith("/")) {
+            serverUrl = serverUrl.substring(0, serverUrl.length() - 1);
+        }
+        String urlStr = serverUrl + "/admin/user/get_info";
+
+        // 构建请求体
+        String jsonBody = "{\"mobile\":\"" + mobile + "\",\"includeDeleted\":false}";
+
+        // 生成认证签名
+        int nonce = RANDOM.nextInt(1000000) + 1;
+        long timestamp = System.currentTimeMillis();
+        String signStr = nonce + "|" + secret + "|" + timestamp;
+        String sign = sha1Hex(signStr);
+
+        // 发送 HTTP POST 请求
+        String response = doPost(urlStr, jsonBody, nonce, timestamp, sign);
+
+        // 输出结果
+        System.out.println("\n===== 返回结果 =====");
+        System.out.println(response);
+    }
+
+    private static String doPost(String urlStr, String body, int nonce, long timestamp, String sign) throws Exception {
+        URL url = new URL(urlStr);
+        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
+        try {
+            conn.setRequestMethod("POST");
+            conn.setRequestProperty("Content-Type", "application/json; charset=utf-8");
+            conn.setRequestProperty("Connection", "Keep-Alive");
+            conn.setRequestProperty("nonce", String.valueOf(nonce));
+            conn.setRequestProperty("timestamp", String.valueOf(timestamp));
+            conn.setRequestProperty("sign", sign);
+            conn.setDoOutput(true);
+            conn.setConnectTimeout(15000);
+            conn.setReadTimeout(15000);
+
+            // 写入请求体
+            try (OutputStream os = conn.getOutputStream()) {
+                os.write(body.getBytes(StandardCharsets.UTF_8));
+                os.flush();
+            }
+
+            int responseCode = conn.getResponseCode();
+
+            // 读取响应
+            InputStream is = (responseCode >= 200 && responseCode < 300)
+                    ? conn.getInputStream()
+                    : conn.getErrorStream();
+
+            StringBuilder sb = new StringBuilder();
+            try (BufferedReader reader = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8))) {
+                String line;
+                while ((line = reader.readLine()) != null) {
+                    sb.append(line);
+                }
+            }
+
+            return sb.toString();
+        } finally {
+            conn.disconnect();
+        }
+    }
+
+    private static String sha1Hex(String input) throws NoSuchAlgorithmException {
+        MessageDigest md = MessageDigest.getInstance("SHA-1");
+        byte[] digest = md.digest(input.getBytes(StandardCharsets.UTF_8));
+        StringBuilder sb = new StringBuilder();
+        for (byte b : digest) {
+            sb.append(String.format("%02x", b & 0xff));
+        }
+        return sb.toString();
+    }
+}
@@ -68,6 +68,10 @@ token.key testim
 ##是否使用AES256加密。默认客户端和服务器都是AES128加密，如果需要开启AES256，需要客户端和IM服务同时开通。
 #encrypt.use_aes256 true

+##当创建一个对象时（用户，群组，频道，机器人等），如果没有传入ID，野火会为这个对象生成一个ID。如果id.use_uuid为true，会使用uuid作为对象ID，否则会使用野火短ID，默认为false。
+## 短ID有个很大的风险是容易被人穷举进行攻击。建议用UUID。
+id.use_uuid true
+
 ##首次登录，是否接收之前的历史消息。
 ##0 不接收历史消息，只接收${message.compensate_time_limit}毫秒以内的消息，由于服务器没有保存已经收取记录，所以如果有超过${message.compensate_time_limit}毫秒之前未收取的消息也不会收取下拉；
 ##1接收，会接收 message.max_queue 配置的条数的历史消息
@@ -91,9 +95,15 @@ message.disable_stranger_chat false
 ##当禁止陌生人聊天时，允许聊天的用户id，比如管理员或者文件传输助手等。用户id以英文逗号分割。
 message.allow_stranger_chat_list admin,FireRobot,wfc_file_transfer

+##当禁止陌生人聊天时，允许聊天的线路。
+#message.allow_stranger_line 100,101
+
 ##黑名单策略，0 发送失败，返回被拉黑的错误码；1 发送成功但消息被服务器直接丢弃
 message.blacklist.strategy 0

+##拉黑对方后，对方不能发送消息给你。这个开关确定拉黑对方后你还能不能给对方发送消息。
+message.blacklist.allow_send_to_black false
+
 ##是否禁止服务器端消息搜索，该功能暂未实现。目前的影响是如果打开，则存储消息时不单独保存_searchable_content字段
 message.disable_remote_search  false

@@ -101,7 +111,7 @@ message.disable_remote_search  false
 ##如果要避免数据库中明文存储消息内容，请打开这个开关和message.disable_remote_search开关
 message.encrypt_message_content false

-##允许客户端撤回用户自己发送的消息时限，单位是秒。
+##允许客户端撤回用户自己发送的消息时限，单位是秒。0是不允许撤回；-1是无限制撤回。
 ##Server API不受此限制，可以撤回任意时限内的消息
 ##群组管理员或群主撤回群成员消息不受此限制，可以撤回任意时限内的消息。但管理员或群主撤回自己的消息还是需要准守此时间限制。
 ##修改此参数需要同步修改客户端UI，客户端UI代码有判断撤回是否显示的逻辑。
@@ -126,6 +136,12 @@ message.global_mute_exception_types 401,402,403,404,405,407,408,410,411
 ## 离线用户推送过期天数，0是永不过期，建议配置为7天。
 message.push_expired_days 7

+## 当会话静音/全局静音/PC在线静音时，普通消息都不会有推送，如果有某些消息类型需要此时保持推送，可以配置到这里。此配置对消息免打扰时段无效。
+## 此配置只影响远程推送，需要客户端处理客户端在线且在后台收到此消息的处理，需要针对这些消息类型加上本地通知。
+## 强制推送消息的MessagePayload中pushContent和pushData至少要存在一个才可以推送。
+## 消息类型以英文逗号分割。
+#message.force_push_types 401,402
+
 ## 群发消息(包括server api群发和全局频道群发)时，目标用户是否来自于t_user表。如果使用野火托管用户信息，请设置为true，否则设置为false。
 message.broadcast.target_from_user_table true

@@ -136,20 +152,61 @@ message.no_forward_admin_message false
 ## 消息转发功能开启时，转发信息是否带上用户clientId和平台类型。
 message.forward_with_client_info false

+## 消息转发功能开启时，转发信息是否带上发送者的用户信息
+message.forward_with_sender_info false
+
+## 消息转发功能开启时，转发信息是否带上目标的信息，单聊时是对方用户信息，群聊时是群组信息，频道时是频道信息
+message.forward_with_target_info false
+
+## 允许发送单聊消息给被封禁用户
+message.allow_send_to_forbidden_user false
+
 ## 机器人回调信息是否带上用户clientId和平台类型。
 robot.callback_with_client_info false

+## 机器人回调信息是否带上发送者的用户信息
+robot.callback_with_sender_info false
+
+## 机器人回调信息是否带上目标的信息，单聊时是对方用户信息，群聊时是群组信息，频道时是频道信息
+robot.callback_with_target_info false
+
+## 是否允许@会话外的机器人。如果为true，单聊或者群聊时，可以@不在会话中的机器人。当机器人收到消息后，可以回复消息。
+## 如果为false，不能@不在会话中的机器人。机器人不在会话中时，也不能回复消息。
+robot.mention_external_robot true
+
+## 机器人获取信息允许的字段，可以获取userId/displayName/portrait，其他需要这里配置允许。
+## 第一位(1)是name， 第二位(2)是mobile，第三(4)位是email，第四位(8)是address，第五位(16)是company，第六位(32)是extra，
+## 第七位(64)是updateDt，第八位(128)是gender，第九位(256)是social，第十位(512)是type。
+## 比如允许获取name和email就是5(1+4)，允许获取name和mobile和company和type就是531（1+2+16+512），允许全部是1023(1+2+...+512)
+#robot.get_user_info_mask 1023
+
+## 机器人应用authToken允许任意host。当为false时，机器人Web应用的host必须和机器人的callback host一致，这样能够增加安全性。
+#robot.application_allow_any_host true
+
 ## 频道回调信息是否带上用户clientId和平台类型。
 channel.callback_with_client_info false

+## 频道回调信息是否带上发送者的用户信息。
+channel.callback_with_sender_info false
+
+## 频道回调信息是否带上频道信息
+channel.callback_with_target_info false
+
+## 频道回调新方式，在新方式下，如果有callback地址就会总是回调客户端发送的消息（包括owner和订阅者）。automatic属性控制订阅者发送的消息是否发给owner， 0发，1不发。
+## 旧的方式是，automatic为0时，订阅者的消息发给owner，不转发消息到callback地址。为1时，把订阅者的消息转发给callback地址，不发给owner。
+channel.new_callback_feature true
+
+## 频道应用authToken允许任意host。当为false时，频道Web应用的host必须和频道的callback host一致，这样能够增加安全性。
+#channel.application_allow_any_host true
+
 ##禁止搜索用户
 friend.disable_search false

 ##禁止按照昵称搜索用户。
 friend.disable_nick_name_search false

-##禁止按照用户id搜索用户，默认为true。
-friend.disable_user_id_search true
+##禁止按照用户id搜索用户，默认为false。
+friend.disable_user_id_search false

 ##禁止发送好友邀请，通过server api添加好友不受此限制(force参数需要为true)
 friend.disable_friend_request false
@@ -163,6 +220,15 @@ friend.reject_request_duration 2592000000
 ##好友请求过期时间，单位是毫秒，默认是7天，0为无限长期限。
 friend.request_expiration_duration 604800000

+##好友请求限制频率，一个用户24小时之内允许请求好友的次数，默认不限频。
+friend.request_rate_limit 30
+
+##如果搜索电话号码，24小时内搜索错误号码几次就不再允许电话号码搜素。防止有人遍历搜索电话号码
+friend.search_mobile_empty_rate_limit 5
+
+##如果搜索用户，24小时内搜索次数。防止有人遍历用户名或者用户ID乱加好友。另外可以禁止ID搜索friend.disable_user_id_search
+friend.search_rate_limit 100
+
 ##请求添加机器人为好友时，机器人是否自动接受，默认为true
 friend.robot_auto_accept true

@@ -204,6 +270,13 @@ group.visible_quit_or_kickoff_notification 0
 ## 是否禁止陌生人拉人入群，默认为false
 group.disable_stranger_invite false

+## 创建群组或者加人时。可能会有成员加入失败（黑名单，或者不允许陌生人拉入群）。当出现有成员失败时，如果此开关为关，操作会失败。
+## 如果此开关打开，操作会返回成功，另外在群里发送一条通知消息 XXX 拒绝加入群组。默认为开。
+group.add_member_allow_part_success true
+
+## 群组信息是否标记删除
+group.enable_mark_deletion true
+
 ## 隐藏用户信息属性类型，2是性别，3是电话号码，4是邮箱，5是地址，6是公司信息，7是社交账号，8是Extra信息。当需要隐藏多个时以英文逗号分开;
 ## 本配置是为了提高安全性，避免把对应信息同步到客户端，这样就能防止程序被破解从而拿到用户关键信息。仅对客户端有效，server api不受影响。
 ## 注意，修改本配置不会对已经同步的信息产生影响。
@@ -212,6 +285,16 @@ group.disable_stranger_invite false
 ## 销毁用户时，用户信息会被清空，deleted字段设置为1，这个开关控制是否保留用户昵称，默认为true。
 user.keep_display_name_when_destroy true

+## 销毁用户时deleted字段设置为1，这个开关控制是否保留其他信息，默认是false。
+user.keep_full_info_when_destroy false
+
+## 销毁用户时，如果user.keep_full_info_when_destroy为true，会保留所有信息，这个开关控制是否保留这个用户信息的电话号码，默认为false。
+## 当保留所有信息且保留电话号码时，用户如果再注册会用到原来的UID，能够看到原来用户的消息，需要考虑一下是否让已删除用户再次注册登录看到之前的消息。
+user.keep_mobile_when_destroy false
+
+## 销毁用户时是否保留归属于这个用户的所有消息记录，默认为false。
+user.keep_messages_when_destroy false
+
 # 好友/好友请求/用户设置 这三类数据同步的最大条目数。之前是客户第一次登录时，会把所有的对应数据一次下载到客户端，但如果有特别多的信息，会导致无法同步到客户端，
 # 因此需要分段多次同步，此开关定义了每次同步的数据的条数。此需要客户端支持，客户端SDK在2021.5.25日后支持此功能。如果确认所有客户端都在这个日志之后才可以打开此设置。
 #sync.data_part_size 1000
@@ -241,15 +324,6 @@ client.request_rate_limit 100
 ##关于对象存储的详细信息请参考：https://docs.wildfirechat.cn/server/oss.html
 media.server.use_qiniu 0

-##媒体类型分类
-#Media_Type_GENERAL = 0,
-#Media_Type_IMAGE = 1,
-#Media_Type_VOICE = 2,
-#Media_Type_VIDEO = 3,
-#Media_Type_FILE = 4,
-#Media_Type_PORTRAIT = 5,
-#Media_Type_FAVORITE = 6
-
 # qiniu media server configuration
 qiniu.server_url  http://up.qbox.me
 qiniu.access_key tU3vdBK5BL5j4N7jI5N5uZgq_HQDo170w5C9Amnn
@@ -272,12 +346,31 @@ qiniu.bucket_portrait_name storage
 qiniu.bucket_portrait_domain http://cdn2.wildfirechat.cn
 qiniu.bucket_favorite_name storage
 qiniu.bucket_favorite_domain http://cdn2.wildfirechat.cn
+## custom的桶是给客户预留的，客户可以上传自己的文件到这3个桶中，野火不会用到这几个桶。如果不需要，可以忽略这几个配置
+qiniu.bucket_custom1_name temp1
+qiniu.bucket_custom1_domain http://temp1.wildfirechat.cn
+qiniu.bucket_custom2_name temp2
+qiniu.bucket_custom2_domain http://temp2.wildfirechat.cn
+qiniu.bucket_custom3_name temp3
+qiniu.bucket_custom3_domain http://temp3.wildfirechat.cn
+qiniu.bucket_pan_name pan
+qiniu.bucket_pan_domain http://pan.wildfirechat.cn

+##媒体类型分类
+#Media_Type_GENERAL = 0,
+#Media_Type_IMAGE = 1,
+#Media_Type_VOICE = 2,
+#Media_Type_VIDEO = 3,
+#Media_Type_FILE = 4,
+#Media_Type_PORTRAIT = 5,
+#Media_Type_FAVORITE = 6,
+#Media_Type_STICKER = 7,
+#Media_Type_MOMENTS = 8

 # local media server configuration
 # 本地媒体服务器配置。
 local.media.storage.root media
-# 如果使用内置文件存储，文件上传后地址默认为 http://server.ip:http_port/fs/5/2021/03/27/08/filename。
+# 如果使用内置文件存储，文件上传后地址默认为 http://server.ip:http_port/fs/5/2021/03/27/08/filename。fs目录下按照类型存放文件，媒体类型见上面注释，比如5就是Media_Type_PORTRAIT，是客户端的头像文件。
 # 如果需要使用nginx添加https支持，请打开下面配置，这样客户端得到的文件地址为 https://example.com/media/fs/5/2021/03/27/08/filename。
 # 需要nginx把请求从https://example.com/media/fs 转到 http://server.ip:http_port/fs。注意需要带上所有header。
 # 尽管内置文件存储可以使用，但是我们还是建议使用专业级别的对象存储服务，社区版可以使用七牛，专业版另外支持阿里云和也是私有对象存储。详情请参考 https://docs.wildfirechat.cn/server/oss.html
@@ -291,7 +384,16 @@ server.multi_endpoint false
 ## 是否支持PC多端登陆，当server.multi_endpoint为true时，此开关无意义，当为false时，可以单独打开PC端多端登录。
 server.multi_pc_endpoint false

-# 多平台连接状态通知（仅当multi_endpoint为false时有效），true时移动端可以收到pc或web端登录的通知。
+## 是否支持PAD多端登陆，当server.multi_endpoint为true时，此开关无意义，当为false时，可以单独打开PAD端多端登录。
+server.multi_pad_endpoint false
+
+## 是否支持可穿戴设备多端登陆，当server.multi_endpoint为true时，此开关无意义，当为false时，可以单独打开可穿戴设备多端登录。
+server.multi_wearable_endpoint false
+
+## 是否支持TV设备多端登陆，当server.multi_endpoint为true时，此开关无意义，当为false时，可以单独打开TV多端登录。
+server.multi_tv_endpoint false
+
+# 多平台连接状态通知（仅当multi_endpoint为false时有效），true时移动端可以收到pc或pad或web端登录的通知。
 server.multi_platform_notification true

 # 当pc或者web在线时，手机是否默认静音，默认为true。注意仅影响默认值，用户可以手动切换是否静音。
@@ -300,7 +402,7 @@ server.mobile_default_silent_when_pc_online true

 ## 客户端是否支持kickoff事件。当客户端被其他端登录踢出时，如果此开关为false时，客户端协议栈上报secret_mismatch。如果此开关为ture时，客户端协议栈上报kicked_off。
 ## 客户端被踢时上报kicked_off是在2021.9.15之后才加上的。如果客户端协议栈全部为此日期之后的版本才可以打开此开关。
-server.client_support_kickoff_event false
+server.client_support_kickoff_event true

 #*********************************************************************
 # Push server configuration
@@ -314,6 +416,10 @@ push.android.server.address http://localhost:8085/android/push
 ##注意回调是单线程回调，接收服务必须在同一内网，且异步处理快速返回，否则会有延迟问题！！
 push.ios.server.address http://localhost:8085/ios/push

+##鸿蒙推送服务器地址
+##注意回调是单线程回调，接收服务必须在同一内网，且异步处理快速返回，否则会有延迟问题！！
+push.harmony.server.address http://localhost:8085/harmony/push
+
 #*********************************************************************
 # 监控配置
 #*********************************************************************
@@ -387,7 +493,14 @@ push.ios.server.address http://localhost:8085/ios/push
 ## 内置文本敏感词过滤处理方法，当命中敏感词后，消息会被记录到t_sensitive_messages表中，然后根据type类型做不同的处理，处理方式如下：
 ## 0 发送失败；1 发送成功但消息被服务器直接丢弃；2 命中的敏感词被替换成***然后正常发送；3 正常发送。
 ## 如果开启 message.sensitive.forward.url 配置，命中敏感词的消息还会被回调到这个地址
-sensitive.filter.type 0
+sensitive.filter.type 2
+
+## 敏感词是否只处理消息。如果为true，只过滤消息；如果为false，会同时过滤用户昵称、群组名和群昵称。
+## 除了消息之外的信息只支持内部敏感词处理，不支持外置审核。
+sensitive.only_message false
+
+## 敏感词添加或者删除有2种方式，一种是通过Server API进行，这种方式会立即生效。另外一种方法是修改数据库，直接中数据库的t_sensitive_word表中处理
+## 修改数据库的方法不会立即生效，IM服务会2个小时重新加载一次敏感词。所以如果直接修改敏感词表，需要等2个小时，或者重启才能生效。

 ## 如果内置敏感词库无法满足您的需求，可以开发部署独立敏感词审核服务。配置如下地址和消息类型，IM服务会把指定消息类型的消息回调到指定地址，内置的敏感词审核和敏感词转发功能就不再起作用了。
 ## 审核服务返回状态码200表示继续发送，如果需要替换内容，返回状态码200并且内容为替换后的内容。返回403表示不允许发送。其它错误继续发送。
@@ -0,0 +1,2 @@
+alter table `t_group` add column `_deleted` tinyint NOT NULL DEFAULT 0;
+
@@ -0,0 +1,13 @@
+DROP TABLE IF EXISTS `t_domain`;
+CREATE TABLE `t_domain` (
+  `_domain_id` varchar(64) NOT NULL PRIMARY KEY,
+  `_name` varchar(64) NOT NULL,
+  `_desc` varchar(256) DEFAULT '',
+  `_email` varchar(64) DEFAULT '',
+  `_tel` varchar(64) DEFAULT '',
+  `_address` varchar(64) DEFAULT '',
+  `_extra` varchar(1024) DEFAULT '',
+  `_dt` bigint(20) NOT NULL
+);
+
+alter table `t_user` add column `_external` tinyint DEFAULT 0;
@@ -0,0 +1 @@
+CREATE INDEX `user_gid_dt_index` ON `t_group_member` (`_gid`, `_dt`);
@@ -0,0 +1 @@
+insert into t_settings(`id`, `_value`,`_desc`) values (2, '文件传输助手,客服,官方', '禁止使用名称，如果有多个，以英文逗号隔开。直接修改数据库，不用重启IM服务');
@@ -0,0 +1 @@
+alter table `t_messages` modify column `_target` varchar(129) NOT NULL;
@@ -0,0 +1 @@
+ALTER TABLE `t_user_session` ADD COLUMN `_ip` varchar(40) DEFAULT '';
@@ -0,0 +1 @@
+CREATE INDEX `user_gid_type_index` ON `t_group_member` (`_gid`, `_type`);
@@ -0,0 +1,13 @@
+
+DROP TABLE IF EXISTS `t_conference`;
+CREATE TABLE `t_conference` (
+  `_id` varchar(64) NOT NULL PRIMARY KEY,
+  `_des` varchar(64) NOT NULL,
+  `_pin` varchar(16) NOT NULL,
+  `_max_publishers` int(11) NOT NULL DEFAULT 0,
+  `_bitrate` int(11) NOT NULL DEFAULT 0,
+  `_advance` tinyint NOT NULL DEFAULT 0,
+  `_recording` tinyint NOT NULL DEFAULT 0,
+  `_create_dt` bigint(20) NOT NULL
+);
+
@@ -0,0 +1,17 @@
+DROP TABLE IF EXISTS `t_join_group_request`;
+CREATE TABLE `t_join_group_request` (
+  `id` int(11) NOT NULL PRIMARY KEY AUTO_INCREMENT,
+  `_uid` varchar(64) NOT NULL,
+  `_gid` varchar(64) NOT NULL,
+  `_mid` varchar(64) NOT NULL,
+  `_request_uid` varchar(64) NOT NULL,
+  `_accept_uid` varchar(64) DEFAULT NULL,
+  `_reason` TEXT DEFAULT NULL,
+  `_extra` TEXT DEFAULT NULL,
+  `_status` tinyint NOT NULL DEFAULT 0,
+  `_dt` bigint(20) NOT NULL,
+  `_read_status` tinyint DEFAULT 0,
+  UNIQUE INDEX `join_group_request_key_index` (`_uid` DESC, `_gid` DESC, `_mid` DESC, `_request_uid` DESC),
+  INDEX `join_group_request_gm_index` (`_gid` DESC, `_mid` DESC),
+  INDEX `join_group_request_sync_index` (`_uid` DESC, `_dt` DESC)
+);
@@ -0,0 +1 @@
+alter table t_friend add index `friend_uid_index` (`_friend_uid`);
@@ -0,0 +1,3 @@
+ALTER TABLE `t_conference` ADD COLUMN `_delete_by` varchar(64) DEFAULT '';
+ALTER TABLE `t_conference` ADD COLUMN `_deleted` tinyint DEFAULT 0;
+ALTER TABLE `t_conference` ADD COLUMN `_delete_dt` bigint(20) DEFAULT 0;
@@ -0,0 +1 @@
+alter table `t_group` add column `_deleted` tinyint NOT NULL DEFAULT 0;
@@ -0,0 +1,16 @@
+DROP TABLE IF EXISTS `t_domain`;
+CREATE TABLE `t_domain` (
+  `_domain_id` varchar(128) NOT NULL PRIMARY KEY,
+  `_name` varchar(64) NOT NULL,
+  `_desc` varchar(256) DEFAULT '',
+  `_email` varchar(64) DEFAULT '',
+  `_tel` varchar(64) DEFAULT '',
+  `_address` varchar(64) DEFAULT '',
+  `_extra` varchar(1024) DEFAULT '',
+  `_dt` bigint(20) NOT NULL
+)
+ENGINE = InnoDB
+DEFAULT CHARACTER SET = utf8mb4
+COLLATE = utf8mb4_unicode_ci;
+
+alter table `t_user` add column `_external` tinyint DEFAULT 0;
@@ -0,0 +1 @@
+CREATE INDEX `user_gid_mid_dt_index` ON `t_group_member` (`_gid`, `_mid`, `_dt`);
@@ -0,0 +1,2 @@
+DROP INDEX `user_gid_mid_dt_index` ON `t_group_member`;
+CREATE INDEX `user_gid_dt_index` ON `t_group_member` (`_gid`, `_dt`);
@@ -0,0 +1 @@
+insert into t_settings(`id`, `_value`,`_desc`) values (2, '文件传输助手,客服,官方', '禁止使用名称，如果有多个，以英文逗号隔开。直接修改数据库，不用重启IM服务');
@@ -0,0 +1,37 @@
+alter table `t_messages` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_0` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_1` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_2` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_3` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_4` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_5` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_6` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_7` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_8` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_9` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_10` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_11` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_12` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_13` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_14` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_15` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_16` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_17` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_18` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_19` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_20` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_21` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_22` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_23` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_24` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_25` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_26` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_27` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_28` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_29` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_30` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_31` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_32` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_33` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_34` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_35` modify column `_target` varchar(129) NOT NULL;
@@ -0,0 +1 @@
+ALTER TABLE `t_user_session` ADD COLUMN `_ip` varchar(40) DEFAULT '';
@@ -0,0 +1 @@
+CREATE INDEX `user_gid_type_index` ON `t_group_member` (`_gid`, `_type`);
@@ -0,0 +1,16 @@
+
+DROP TABLE IF EXISTS `t_conference`;
+CREATE TABLE `t_conference` (
+  `_id` varchar(64) NOT NULL PRIMARY KEY,
+  `_des` varchar(64) NOT NULL,
+  `_pin` varchar(16) NOT NULL,
+  `_max_publishers` int(11) NOT NULL DEFAULT 0,
+  `_bitrate` int(11) NOT NULL DEFAULT 0,
+  `_advance` tinyint NOT NULL DEFAULT 0,
+  `_recording` tinyint NOT NULL DEFAULT 0,
+  `_create_dt` bigint(20) NOT NULL
+)
+ENGINE = InnoDB
+DEFAULT CHARACTER SET = utf8mb4
+COLLATE = utf8mb4_unicode_ci;
+
@@ -0,0 +1,21 @@
+
+DROP TABLE IF EXISTS `t_join_group_request`;
+CREATE TABLE `t_join_group_request` (
+  `id` int(11) NOT NULL PRIMARY KEY AUTO_INCREMENT,
+  `_uid` varchar(64) NOT NULL,
+  `_gid` varchar(64) NOT NULL,
+  `_mid` varchar(64) NOT NULL,
+  `_request_uid` varchar(64) NOT NULL,
+  `_accept_uid` varchar(64) DEFAULT NULL,
+  `_reason` TEXT DEFAULT NULL,
+  `_extra` TEXT DEFAULT NULL,
+  `_status` tinyint NOT NULL DEFAULT 0,
+  `_dt` bigint(20) NOT NULL,
+  `_read_status` tinyint DEFAULT 0,
+  UNIQUE INDEX `join_group_request_key_index` (`_uid` DESC, `_gid` DESC, `_mid` DESC, `_request_uid` DESC),
+  INDEX `join_group_request_gm_index` (`_gid` DESC, `_mid` DESC),
+  INDEX `join_group_request_sync_index` (`_uid` DESC, `_dt` DESC)
+)
+ENGINE = InnoDB
+DEFAULT CHARACTER SET = utf8mb4
+COLLATE = utf8mb4_unicode_ci;
@@ -0,0 +1 @@
+alter table t_friend add index `friend_uid_index` (`_friend_uid`);
@@ -0,0 +1,3 @@
+ALTER TABLE `t_conference` ADD COLUMN `_delete_by` varchar(64) DEFAULT '';
+ALTER TABLE `t_conference` ADD COLUMN `_deleted` tinyint DEFAULT 0;
+ALTER TABLE `t_conference` ADD COLUMN `_delete_dt` bigint(20) DEFAULT 0;
@@ -9,6 +9,7 @@ server {
    root   html;
    index  index.html index.htm index.php;

+    #同步服务设置
    location /route {
        proxy_set_header  Host  $host;
        proxy_set_header  X-real-ip $remote_addr;
@@ -16,7 +17,7 @@ server {
        proxy_pass  http://imserver;
    }

-    #社区版需要启用下面一段，专业版不能用
+    #客户端短连接业务
    location /im {
        proxy_set_header  Host  $host;
        proxy_set_header  X-real-ip $remote_addr;
@@ -24,14 +25,21 @@ server {
        proxy_pass  http://imserver;
    }

+    #版本检查/api/version，可以删掉
    location /api {
        proxy_pass  http://imserver;
    }

+    #内置文件上传和下载
    location /fs {
+        client_max_body_size 200M;
+        proxy_set_header  Host  $host;
+        proxy_set_header  X-real-ip $remote_addr;
+        proxy_set_header  X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_pass  http://imserver;
    }

+    #机器人API
    location /robot {
        proxy_set_header  Host  $host;
        proxy_set_header  X-real-ip $remote_addr;
@@ -39,6 +47,7 @@ server {
        proxy_pass  http://imserver;
    }

+    #频道API
    location /channel {
        proxy_set_header  Host  $host;
        proxy_set_header  X-real-ip $remote_addr;
@@ -5,7 +5,7 @@
        <relativePath>../</relativePath>
        <artifactId>wildfirechat-parent</artifactId>
        <groupId>cn.wildfirechat</groupId>
-        <version>1.2.2</version>
+        <version>1.4.8</version>
    </parent>

    <artifactId>moquette-broker</artifactId>
@@ -37,14 +37,14 @@
        <!--用于与slf4j保持桥接-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
-            <artifactId>log4j-slf4j-impl</artifactId>
-            <version>2.17.2</version>
+            <artifactId>log4j-slf4j2-impl</artifactId>
+            <version>2.22.1</version>
        </dependency>
        <!-- slf4j核心包-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
-            <version>1.7.25</version>
+            <version>2.0.12</version>
        </dependency>
        <dependency>
            <groupId>com.lmax</groupId>
@@ -65,6 +65,18 @@
            <version>1.1.1</version>
        </dependency>

+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.13.2</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.google.protobuf</groupId>
+            <artifactId>protobuf-java</artifactId>
+            <version>3.25.3</version>
+        </dependency>
+
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-common</artifactId>
@@ -112,9 +124,7 @@
            <artifactId>netty-transport-native-epoll</artifactId>
            <version>${netty.version}</version>
            <classifier>linux-x86_64</classifier>
-            <!--
-            <classifier>${os.detected.name}-${os.detected.arch}</classifier>
-             -->
+<!--            <classifier>linux-aarch_64</classifier>-->
        </dependency>

        <dependency>
@@ -129,37 +139,18 @@
            <version>3.11.5</version>
        </dependency>

-        <!-- https://mvnrepository.com/artifact/com.xiaoleilu/hutool -->
        <dependency>
-            <groupId>com.xiaoleilu</groupId>
-            <artifactId>hutool</artifactId>
-            <version>2.15.11</version>
+            <groupId>cn.hutool</groupId>
+            <artifactId>hutool-all</artifactId>
+            <version>5.8.26</version>
        </dependency>

-        <!-- Test dependencies -->
-        <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
-            <version>4.13.1</version>
-            <scope>test</scope>
-        </dependency>
-
-
-        <!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.4</version>
        </dependency>

-        <!-- needs extra dependencies: objenesis & hamcrest -->
-        <dependency>
-            <groupId>org.mockito</groupId>
-            <artifactId>mockito-core</artifactId>
-            <version>1.9.0</version>
-            <scope>test</scope>
-        </dependency>
-
        <dependency>
            <groupId>org.fusesource.mqtt-client</groupId>
            <artifactId>mqtt-client</artifactId>
@@ -172,28 +163,6 @@
            <version>1.2.2</version>
        </dependency>

-        <dependency>
-            <groupId>org.eclipse.jetty.websocket</groupId>
-            <artifactId>websocket-client</artifactId>
-            <version>9.2.0.M1</version>
-            <scope>test</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>org.assertj</groupId>
-            <artifactId>assertj-core</artifactId>
-            <!-- use 2.6.0 for Java 7 projects -->
-            <version>2.6.0</version>
-            <scope>test</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>com.h2database</groupId>
-            <artifactId>h2</artifactId>
-            <version>1.4.191</version>
-            <scope>test</scope>
-        </dependency>
-
        <dependency>
            <groupId>com.qiniu</groupId>
            <artifactId>qiniu-java-sdk</artifactId>
@@ -214,14 +183,12 @@
            <scope>runtime</scope>
        </dependency>

-        <!-- https://mvnrepository.com/artifact/com.squareup.okhttp3/okhttp -->
        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
-            <version>3.13.1</version>
+            <version>4.12.0</version>
        </dependency>

-        <!-- https://mvnrepository.com/artifact/org.flywaydb/flyway-core -->
        <dependency>
            <groupId>org.flywaydb</groupId>
            <artifactId>flyway-core</artifactId>
@@ -244,60 +211,6 @@

    <build>
        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-surefire-plugin</artifactId>
-                <configuration>
-                    <includes>
-                        <include>**/*Test.java</include>
-                    </includes>
-                </configuration>
-            </plugin>
-
-            <!-- Generate the test-jar -->
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-jar-plugin</artifactId>
-                <version>3.0.2</version>
-                <executions>
-                    <execution>
-                        <goals>
-                            <goal>test-jar</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-
-            <!-- Includes to generate OSGi headers -->
-            <plugin>
-                <artifactId>maven-jar-plugin</artifactId>
-                <configuration>
-                    <archive>
-                        <manifestFile>${project.build.outputDirectory}/META-INF/MANIFEST.MF</manifestFile>
-                    </archive>
-                </configuration>
-                <executions>
-                    <execution>
-                        <goals>
-                            <goal>test-jar</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-            <plugin>
-                <groupId>org.apache.felix</groupId>
-                <artifactId>maven-bundle-plugin</artifactId>
-                <executions>
-                    <execution>
-                        <id>bundle-manifest</id>
-                        <phase>process-classes</phase>
-                        <goals>
-                            <goal>manifest</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-
            <plugin>
                <groupId>pl.project13.maven</groupId>
                <artifactId>git-commit-id-plugin</artifactId>
@@ -34,7 +34,10 @@ public class PushMessage {
    public String voipDeviceToken;
    public boolean isHiddenDetail;
    public String language;
+    public boolean republish;
    public long messageId;
+    public long callStartUid;
+    public int existBadgeNumber;

    public PushMessage(String sender, int conversationType, String target, int line, int messageContentType, long serverTime, String senderName, String senderPortrait, String targetName, String targetPortrait, int unReceivedMsg, int mentionedType, boolean isHiddenDetail, String language) {
        this.sender = sender;
@@ -65,6 +68,7 @@ public class PushMessage {
        this.mentionedType = mentionedType;
        this.isHiddenDetail = isHiddenDetail;
        this.language = language;
+        this.republish = messageContentType == 80 || messageContentType == 81;
    }
    public PushMessage(String sender, String target, long serverTime, String senderName, int unReceivedMsg, String language, int pushMessageType) {
        this.sender = sender;
@@ -24,8 +24,7 @@ import win.liyufan.im.Utility;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;

-import static io.moquette.BrokerConstants.PUSH_ANDROID_SERVER_ADDRESS;
-import static io.moquette.BrokerConstants.PUSH_IOS_SERVER_ADDRESS;
+import static io.moquette.BrokerConstants.*;
 import static win.liyufan.im.HttpUtils.HttpPostType.POST_TYPE_Push;

 public class PushServer {
@@ -47,6 +46,7 @@ public class PushServer {

    private String androidPushServerUrl;
    private String iOSPushServerUrl;
+    private String harmonyPushServerUrl;

    private PushServer() {
    }
@@ -59,6 +59,7 @@ public class PushServer {
        this.sessionsStore = sessionsStore;
        this.androidPushServerUrl = config.getProperty(PUSH_ANDROID_SERVER_ADDRESS);
        this.iOSPushServerUrl = config.getProperty(PUSH_IOS_SERVER_ADDRESS);
+        this.harmonyPushServerUrl = config.getProperty(PUSH_HARMONY_SERVER_ADDRESS);
    }

    public void pushMessage(PushMessage pushMessage, String deviceId, String pushContent) {
@@ -80,10 +81,6 @@ public class PushServer {
        }

        MemorySessionStore.Session session = sessionsStore.getSession(deviceId);
-        int badge = session.getUnReceivedMsgs();
-        if (badge <= 0) {
-            badge = 1;
-        }
        if (StringUtil.isNullOrEmpty(session.getDeviceToken())) {
            LOG.warn("Device token is empty for device {}", deviceId);
            return;
@@ -93,13 +90,25 @@ public class PushServer {
        pushMessage.pushType = session.getPushType();
        pushMessage.pushContent = pushContent;
        pushMessage.deviceToken = session.getDeviceToken();
-        pushMessage.unReceivedMsg = badge;
        pushMessage.userId = session.getUsername();
-        if (session.getPlatform() == ProtoConstants.Platform.Platform_iOS || session.getPlatform() == ProtoConstants.Platform.Platform_Android) {
+        if (session.getPlatform() == ProtoConstants.Platform.Platform_iOS ||
+            session.getPlatform() == ProtoConstants.Platform.Platform_iPad ||
+            session.getPlatform() == ProtoConstants.Platform.Platform_Android ||
+            session.getPlatform() == ProtoConstants.Platform.Platform_APad ||
+            session.getPlatform() == ProtoConstants.Platform.Platform_Harmony ||
+            session.getPlatform() == ProtoConstants.Platform.Platform_HarmonyPad ||
+            session.getPlatform() == ProtoConstants.Platform.Platform_AppleTV ||
+            session.getPlatform() == ProtoConstants.Platform.Platform_AndroidTV ||
+            session.getPlatform() == ProtoConstants.Platform.Platform_HarmonyTV ||
+            session.getPlatform() == ProtoConstants.Platform.Platform_HarmonyWearable ||
+            session.getPlatform() == ProtoConstants.Platform.Platform_AndroidWearable
+        ) {
            String url = androidPushServerUrl;
-            if (session.getPlatform() == ProtoConstants.Platform.Platform_iOS) {
+            if (session.getPlatform() == ProtoConstants.Platform.Platform_iOS || session.getPlatform() == ProtoConstants.Platform.Platform_iPad || session.getPlatform() == ProtoConstants.Platform.Platform_AppleTV) {
                url = iOSPushServerUrl;
                pushMessage.voipDeviceToken = session.getVoipDeviceToken();
+            } else if (session.getPlatform() == ProtoConstants.Platform.Platform_Harmony || session.getPlatform() == ProtoConstants.Platform.Platform_HarmonyPad || session.getPlatform() == ProtoConstants.Platform.Platform_HarmonyWearable || session.getPlatform() == ProtoConstants.Platform.Platform_HarmonyTV) {
+                url = harmonyPushServerUrl;
            }
            HttpUtils.httpJsonPost(url, gson.toJson(pushMessage, pushMessage.getClass()), POST_TYPE_Push);
        } else {
@@ -35,6 +35,9 @@ public class ThreadPoolExecutorWrapper {
        executor.execute(() -> {
            try {
                task.run();
+            } catch (Exception e) {
+                e.printStackTrace();
+                LOG.info("execute error = {}", e.toString());
            } finally {
                int endCount = runCounter.decrementAndGet();
                LOG.debug("Finish task and current task count {} use time {}", endCount, System.currentTimeMillis()-startTime);
@@ -1,8 +1,6 @@
 package com.xiaoleilu.loServer;

-import com.xiaoleilu.hutool.log.Log;
-import com.xiaoleilu.hutool.log.StaticLog;
-import com.xiaoleilu.hutool.util.DateUtil;
+import cn.hutool.core.date.DateUtil;
 import com.xiaoleilu.loServer.action.Action;
 import com.xiaoleilu.loServer.action.ClassUtil;
 import com.xiaoleilu.loServer.annotation.Route;
@@ -1,6 +1,6 @@
 package com.xiaoleilu.loServer;

-import com.xiaoleilu.hutool.util.DateUtil;
+import cn.hutool.core.date.DateUtil;
 import com.xiaoleilu.loServer.action.Action;
 import com.xiaoleilu.loServer.annotation.Route;
 import com.xiaoleilu.loServer.handler.AdminActionHandler;
@@ -5,11 +5,9 @@ import java.nio.charset.Charset;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;

-import com.xiaoleilu.hutool.lang.Singleton;
-import com.xiaoleilu.hutool.log.Log;
-import com.xiaoleilu.hutool.log.StaticLog;
-import com.xiaoleilu.hutool.util.FileUtil;
-import com.xiaoleilu.hutool.util.StrUtil;
+import cn.hutool.core.io.FileUtil;
+import cn.hutool.core.lang.Singleton;
+import cn.hutool.core.util.StrUtil;
 import com.xiaoleilu.loServer.action.Action;
 import com.xiaoleilu.loServer.action.DefaultIndexAction;
 import com.xiaoleilu.loServer.action.UnknownErrorAction;
@@ -189,7 +187,7 @@ public class ServerSetting {
 	 * @param filterClass Filter类
 	 */
 	public static void setFilter(String path, Class<? extends Filter> filterClass) {
-		setFilter(path, (Filter)Singleton.get(filterClass));
+		setFilter(path, (Filter) Singleton.get(filterClass));
 	}
 	//----------------------------------------------------------------------------------------------- Filter end
 	
@@ -8,9 +8,13 @@

 package com.xiaoleilu.loServer.action;

+import cn.wildfirechat.common.IMExceptionEvent;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
+import com.google.gson.JsonSyntaxException;
 import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.action.channel.ChannelAction;
+import com.xiaoleilu.loServer.action.robot.RobotAction;
 import com.xiaoleilu.loServer.annotation.RequireAuthentication;
 import com.xiaoleilu.loServer.handler.Request;
 import com.xiaoleilu.loServer.handler.Response;
@@ -23,7 +27,10 @@ import io.netty.handler.codec.http.FullHttpRequest;
 import io.netty.handler.codec.http.HttpRequest;
 import io.netty.handler.codec.http.HttpResponseStatus;
 import cn.wildfirechat.common.ErrorCode;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import win.liyufan.im.RateLimiter;
+import win.liyufan.im.Utility;

 import java.nio.charset.StandardCharsets;

@@ -38,6 +45,7 @@ import static io.moquette.BrokerConstants.*;
 */

 abstract public class Action {
+    private static final Logger LOG = LoggerFactory.getLogger(Action.class);
    public static IMessagesStore messagesStore = null;
    public static ISessionsStore sessionsStore = null;
    protected static final Gson gson = new GsonBuilder().disableHtmlEscaping().create();
@@ -136,7 +144,7 @@ abstract public class Action {
                errorCode = ErrorCode.ERROR_CODE_SUCCESS;
            }

-            RestResult result = RestResult.resultOf(errorCode, errorCode.getMsg(), RestResult.resultOf(errorCode));
+            RestResult result = RestResult.resultOf(errorCode, errorCode.getMsg(), null);
            response.setContent(gson.toJson(result));
            response.send();
        }
@@ -153,9 +161,22 @@ abstract public class Action {
            FullHttpRequest fullHttpRequest = (FullHttpRequest) request;
            byte[] bytes = Utils.readBytesAndRewind(fullHttpRequest.content());
            String content = new String(bytes, StandardCharsets.UTF_8);//contribute by JiaRG from github
-            
-            T t = gson.fromJson(content, cls);
-            return t;
+
+            try {
+                T t = gson.fromJson(content, cls);
+                return t;
+            } catch (JsonSyntaxException e) {
+                e.printStackTrace();
+                LOG.error("Object {} from json {} failure", cls.getName(), content);
+                int exception = IMExceptionEvent.EventType.ADMIN_API_Exception;
+                if (this instanceof RobotAction) {
+                    exception = IMExceptionEvent.EventType.ROBOT_API_Exception;
+                } else if (this instanceof ChannelAction) {
+                    exception = IMExceptionEvent.EventType.CHANNEL_API_Exception;
+                }
+                Utility.printExecption(LOG, e, exception);
+                throw new RuntimeException(e);
+            }
        }
        return null;
    }
@@ -1,20 +1,22 @@
 package com.xiaoleilu.loServer.action;

 import java.io.File;
+import java.io.IOException;
 import java.io.UnsupportedEncodingException;
 import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.nio.file.Files;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.Locale;
 import java.util.regex.Pattern;

+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.io.FileUtil;
+import cn.hutool.core.util.ReUtil;
+import cn.hutool.core.util.StrUtil;
 import com.hazelcast.core.HazelcastInstance;
-import com.xiaoleilu.hutool.log.Log;
-import com.xiaoleilu.hutool.log.StaticLog;
-import com.xiaoleilu.hutool.util.DateUtil;
-import com.xiaoleilu.hutool.util.FileUtil;
-import com.xiaoleilu.hutool.util.ReUtil;
-import com.xiaoleilu.hutool.util.StrUtil;
+import com.hazelcast.util.StringUtil;
 import com.xiaoleilu.loServer.ServerSetting;
 import com.xiaoleilu.loServer.handler.Request;
 import com.xiaoleilu.loServer.handler.Response;
@@ -24,6 +26,8 @@ import io.netty.handler.codec.http.HttpHeaderNames;
 import io.netty.handler.codec.http.HttpResponseStatus;
 import org.slf4j.LoggerFactory;

+import static cn.hutool.core.date.DatePattern.HTTP_DATETIME_PATTERN;
+
 /**
 * 默认的主页Action，当访问主页且没有定义主页Action时，调用此Action
 * 
@@ -90,13 +94,28 @@ public class FileAction extends Action {
        }

        response.setContent(file);
-        response.setHeader("Content-Disposition", "attachment; filename=\"" + file.getName() + "\"");
+        if (isAudioOrVideoFile(file.getName())) {
+            response.setHeader("Accept-Ranges", "bytes");
+        } else {
+            response.setHeader("Content-Disposition", "attachment; filename=\"" + file.getName() + "\"");
+        }

        return true;
    }

+    private static boolean isAudioOrVideoFile(String name) {
+        try {
+            if (StringUtil.isNullOrEmpty(name)) return false;
+
+            String mimeType = Files.probeContentType(new File(name).toPath());
+            return mimeType != null && (mimeType.startsWith("audio/") || mimeType.startsWith("video/"));
+        } catch (IOException e) {
+            return false;
+        }
+    }
+
    private static final Pattern INSECURE_URI = Pattern.compile(".*[<>&\"].*");
-	private static final SimpleDateFormat HTTP_DATE_FORMATER = new SimpleDateFormat(DateUtil.HTTP_DATETIME_PATTERN, Locale.US);
+	private static final SimpleDateFormat HTTP_DATE_FORMATER = new SimpleDateFormat(HTTP_DATETIME_PATTERN, Locale.US);

 	
 	/**
@@ -1,9 +1,6 @@
 package com.xiaoleilu.loServer.action;

 import com.hazelcast.core.HazelcastInstance;
-import com.xiaoleilu.hutool.log.Log;
-import com.xiaoleilu.hutool.log.StaticLog;
-import com.xiaoleilu.hutool.util.StrUtil;
 import com.xiaoleilu.loServer.handler.Request;
 import com.xiaoleilu.loServer.handler.Response;
 import io.moquette.spi.IMessagesStore;
@@ -11,6 +11,7 @@ package com.xiaoleilu.loServer.action;
 import cn.wildfirechat.proto.ProtoConstants;
 import cn.wildfirechat.proto.WFCMessage;
 import com.google.protobuf.InvalidProtocolBufferException;
+import com.hazelcast.util.StringUtil;
 import com.xiaoleilu.loServer.annotation.HttpMethod;
 import com.xiaoleilu.loServer.annotation.Route;
 import com.xiaoleilu.loServer.handler.Request;
@@ -28,7 +29,9 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import cn.wildfirechat.common.ErrorCode;

+import java.net.InetSocketAddress;
 import java.util.Base64;
+import java.util.Map;
 import java.util.concurrent.Executor;

@Route("/route")
@@ -111,6 +114,12 @@ public class RouteAction extends Action {
                WFCMessage.IMHttpWrapper wrapper = WFCMessage.IMHttpWrapper.parseFrom(bytes);
                String token = wrapper.getToken();
                String userId = Tokenor.getUserId(token.getBytes());
+
+                String remote = ((InetSocketAddress) ctx.channel().remoteAddress())
+                    .getAddress().getHostAddress();
+                String ip = computeRealIp(request.getHeaders(), remote);
+
+
                LOG.info("RouteAction token={}, userId={}", token, userId);
                if (userId == null) {
                    sendResponse(response, ErrorCode.ERROR_CODE_TOKEN_ERROR, null);
@@ -119,6 +128,8 @@ public class RouteAction extends Action {
                        @Override
                        public void onSuccess(byte[] result) {
                            sendResponse(response, null, result);
+                            //save ip after success response.
+                            sessionsStore.updateSessionIp(userId, wrapper.getClientId(), ip);
                        }

                        @Override
@@ -147,6 +158,20 @@ public class RouteAction extends Action {
        return true;
    }

+    private String computeRealIp(Map<String, String> h, String remote) {
+        String xff = h.get("X-Forwarded-For");
+        if (xff != null && !xff.isEmpty() && !"unknown".equalsIgnoreCase(xff)) {
+            int idx = xff.indexOf(',');
+            String first = (idx > 0 ? xff.substring(0, idx) : xff).trim();
+            return first;
+        }
+        String xri = h.get("X-Real-IP");
+        if (xri != null && !xri.isEmpty() && !"unknown".equalsIgnoreCase(xri)) {
+            return xri;
+        }
+        return remote;
+    }
+
    private void sendResponse(Response response, ErrorCode errorCode, byte[] contents) {
        response.setStatus(HttpResponseStatus.OK);
        if (contents == null) {
@@ -4,9 +4,6 @@ import java.io.PrintWriter;
 import java.io.StringWriter;

 import com.hazelcast.core.HazelcastInstance;
-import com.xiaoleilu.hutool.log.Log;
-import com.xiaoleilu.hutool.log.StaticLog;
-import com.xiaoleilu.hutool.util.StrUtil;
 import com.xiaoleilu.loServer.handler.Request;
 import com.xiaoleilu.loServer.handler.Response;

@@ -24,6 +24,8 @@ import org.slf4j.LoggerFactory;

 import java.io.File;
 import java.io.RandomAccessFile;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.UUID;
@@ -42,8 +44,8 @@ public class UploadFileAction extends Action {

    }

-    public static String getToken(int type) {
-        String signKey = KEY + "|" + (System.currentTimeMillis()) + "|" + type;
+    public static String getToken(int type, String key) {
+        String signKey = KEY + "|" + (System.currentTimeMillis()) + "|" + type + "|" + key;
        try {
            return DES.encryptDES(signKey);
        } catch (Exception e) {
@@ -53,14 +55,17 @@ public class UploadFileAction extends Action {
        return null;
    }

-    public static int validateToken(String token) throws InvalidateTokenExecption {
+    public static int validateToken(String token, String[] fileNames) throws InvalidateTokenExecption {
        try {
            String signKey = DES.decryptDES(token);
            String[] parts = signKey.split("\\|");
-            if(parts.length == 3) {
+            if(parts.length >= 3) {
                if(parts[0].equals(KEY)) {
                    long timestamp = Long.parseLong(parts[1]);
                    if(Math.abs(System.currentTimeMillis() - timestamp) < 2 * 60 * 60 * 1000) {
+                        if(parts.length == 4) {
+                            fileNames[0] = parts[3];
+                        }
                        return Integer.parseInt(parts[2]);
                    }
                }
@@ -151,11 +156,14 @@ public class UploadFileAction extends Action {
        try {
            int[] bucket = new int[1];
            bucket[0] = -1;
+            String[] fileNames = new String[1];
+            fileNames[0] = null;
+
            while (decoder.hasNext()) {
                InterfaceHttpData data = decoder.next();
                if (data != null) {
                    try {
-                        if(!writeFileUploadData(data, response, requestId, isKeepAlive, bucket)) {
+                        if(!writeFileUploadData(data, response, requestId, isKeepAlive, bucket, fileNames)) {
                            break;
                        }
                    } finally {
@@ -171,12 +179,15 @@ public class UploadFileAction extends Action {
    /**
     * writeFileUploadData
     */
-    private boolean writeFileUploadData(InterfaceHttpData data, Response response, String requestId, boolean isKeepAlive, int[] bucket) {
+    private boolean writeFileUploadData(InterfaceHttpData data, Response response, String requestId, boolean isKeepAlive, int[] bucket, String[] fileNames) {
        try {
            if (data.getHttpDataType() == InterfaceHttpData.HttpDataType.FileUpload) {
                FileUpload fileUpload = (FileUpload) data;

                String remoteFileName = fileUpload.getFilename();
+                if(fileNames[0] != null) {
+                    remoteFileName = fileNames[0];
+                }
                long remoteFileSize = fileUpload.length();

                if(bucket[0] == -1) {
@@ -213,7 +224,7 @@ public class UploadFileAction extends Action {
                    return false;
                }

-
+                remoteFileName = getSafeFileName(remoteFileName);

                String remoteFileExt = "";
                if (remoteFileName.lastIndexOf(".") == -1) {
@@ -284,9 +295,10 @@ public class UploadFileAction extends Action {

                        savedThunkSize += readableBytesSize;
                        offset += readableBytesSize;
+                        byteBuf.release();
+                        byteBuf = null;

                        if (savedThunkSize >= remoteFileSize) {
-                            byteBuf.release();
                            fileUpload.release();

                            response.setStatus(HttpResponseStatus.OK);
@@ -320,7 +332,7 @@ public class UploadFileAction extends Action {
                    String token = attribute.getValue();

                    try {
-                        bucket[0] = validateToken(token);
+                        bucket[0] = validateToken(token, fileNames);
                    } catch (InvalidateTokenExecption e) {
                        logger.error("无效的token!", e);
                        response.setStatus(HttpResponseStatus.BAD_REQUEST);
@@ -338,6 +350,15 @@ public class UploadFileAction extends Action {
        return true;
    }

+    private static String getSafeFileName(String originalFilename) {
+        // Paths.get() 会解析路径，getFileName() 只取最后一部分（纯文件名）
+        Path filenamePath = Paths.get(originalFilename.trim());
+        String safeFilename = filenamePath.getFileName().toString();
+        // 额外过滤特殊字符（可选，根据业务需要）
+        safeFilename = safeFilename.replaceAll("[\\\\/:*?\"<>|]", "_");
+        return safeFilename.isEmpty() ? "default_file_" + System.currentTimeMillis() : safeFilename;
+    }
+
    public static void put(File file, long pos, byte[] data) throws Exception {
        RandomAccessFile raf = null;
        try {
@@ -51,14 +51,7 @@ public class AliasPutAction extends AdminAction {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
-                    if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
-                        byte[] data = new byte[byteBuf.readableBytes()];
-                        byteBuf.readBytes(data);
-                        String channelId = new String(data);
-                        return new Result(ErrorCode.ERROR_CODE_SUCCESS, new OutputCreateChannel(channelId));
-                    } else {
-                        return new Result(errorCode);
-                    }
+                    return new Result(errorCode);
                });
                return false;
            } else {
@@ -0,0 +1,41 @@
+package com.xiaoleilu.loServer.action.admin;
+
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.InputSubscribeChannelBatch;
+import cn.wildfirechat.proto.ProtoConstants;
+import cn.wildfirechat.proto.WFCMessage;
+
+import com.hazelcast.util.StringUtil;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.handler.codec.http.HttpResponseStatus;
+
+import java.util.concurrent.Executor;
+
+
+@Route(APIPath.Batch_Subscribe_Channel)
+@HttpMethod("POST")
+public class ChannelSubscriberBatchAction extends AdminAction {
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            InputSubscribeChannelBatch input = getRequestBody(request.getNettyRequest(), InputSubscribeChannelBatch.class);
+            if (input != null && !StringUtil.isNullOrEmpty(input.getChannelId()) && input.getUserIds() != null && !input.getUserIds().isEmpty() ) {
+                ErrorCode errorCode = messagesStore.batchListenChannel(input.getChannelId(), input.getUserIds(), input.getSubscribe()>0);
+                sendResponse(response, errorCode, null);
+            } else {
+                response.setStatus(HttpResponseStatus.OK);
+                RestResult result = RestResult.resultOf(ErrorCode.INVALID_PARAMETER);
+                response.setContent(gson.toJson(result));
+            }
+        }
+        return true;
+    }
+}
@@ -53,8 +53,11 @@ public class CreateChannelAction extends AdminAction {
                    if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
                        byte[] data = new byte[byteBuf.readableBytes()];
                        byteBuf.readBytes(data);
-                        String channelId = new String(data);
-                        return new Result(ErrorCode.ERROR_CODE_SUCCESS, new OutputCreateChannel(channelId));
+                        String str = new String(data);
+                        String[] ss = str.split("\\|");
+                        String channelId = ss[0];
+                        String secret = ss[1];
+                        return new Result(ErrorCode.ERROR_CODE_SUCCESS, new OutputCreateChannel(channelId, secret));
                    } else {
                        return new Result(errorCode);
                    }
@@ -48,10 +48,6 @@ public class CreateChatroomAction extends AdminAction {
                    inputCreateChatroom.setChatroomId(messagesStore.getShortUUID());
                }

-                if (inputCreateChatroom.getPortrait() == null || inputCreateChatroom.getPortrait().length() == 0) {
-                    inputCreateChatroom.setPortrait("https://avatars.io/gravatar/" + inputCreateChatroom.getChatroomId());
-                }
-
                WFCMessage.ChatroomInfo info = inputCreateChatroom.toChatroomInfo();
                messagesStore.createChatroom(inputCreateChatroom.getChatroomId(), info);
                setResponseContent(RestResult.ok(new OutputCreateChatroom(inputCreateChatroom.getChatroomId())), response);
@@ -45,23 +45,13 @@ public class CreateRobotAction extends AdminAction {
            if (inputCreateRobot != null
                && !StringUtil.isNullOrEmpty(inputCreateRobot.getName())) {

-                if(StringUtil.isNullOrEmpty(inputCreateRobot.getPassword())) {
-                    inputCreateRobot.setPassword(UUIDGenerator.getUUID());
-                }
-
                if(StringUtil.isNullOrEmpty(inputCreateRobot.getUserId())) {
                    inputCreateRobot.setUserId(messagesStore.getShortUUID());
                }

-                if (inputCreateRobot.getPortrait() == null || inputCreateRobot.getPortrait().length() == 0) {
-                    inputCreateRobot.setPortrait("https://avatars.io/gravatar/" + inputCreateRobot.getUserId());
-                }
-
                WFCMessage.User newUser = inputCreateRobot.toUser();
-
-
                try {
-                    messagesStore.addUserInfo(newUser, inputCreateRobot.getPassword());
+                    messagesStore.addUserInfo(newUser);
                } catch (Exception e) {
                    e.printStackTrace();
                    Utility.printExecption(LOG, e, IMExceptionEvent.EventType.ADMIN_API_Exception);
@@ -47,10 +47,6 @@ public class CreateUserAction extends AdminAction {
                && !StringUtil.isNullOrEmpty(inputCreateUser.getName())
                && (inputCreateUser.getType() == ProtoConstants.UserType.UserType_Normal || inputCreateUser.getType() == ProtoConstants.UserType.UserType_Admin || inputCreateUser.getType() == ProtoConstants.UserType.UserType_Super_Admin)) {

-                if(StringUtil.isNullOrEmpty(inputCreateUser.getPassword())) {
-                    inputCreateUser.setPassword(UUIDGenerator.getUUID());
-                }
-
                if(StringUtil.isNullOrEmpty(inputCreateUser.getUserId())) {
                    inputCreateUser.setUserId(messagesStore.getShortUUID());
                }
@@ -60,7 +56,7 @@ public class CreateUserAction extends AdminAction {
                if (inputCreateUser.getName() != null)
                    newUserBuilder.setName(inputCreateUser.getName());
                if (inputCreateUser.getDisplayName() != null)
-                    newUserBuilder.setDisplayName(StringUtil.isNullOrEmpty(inputCreateUser.getDisplayName()) ? inputCreateUser.getName() : inputCreateUser.getDisplayName());
+                    newUserBuilder.setDisplayName(inputCreateUser.getDisplayName());
                if (inputCreateUser.getPortrait() != null)
                    newUserBuilder.setPortrait(inputCreateUser.getPortrait());
                if (inputCreateUser.getEmail() != null)
@@ -69,11 +65,8 @@ public class CreateUserAction extends AdminAction {
                    newUserBuilder.setAddress(inputCreateUser.getAddress());
                if (inputCreateUser.getCompany() != null)
                    newUserBuilder.setCompany(inputCreateUser.getCompany());
-
                if (inputCreateUser.getSocial() != null)
                    newUserBuilder.setSocial(inputCreateUser.getSocial());
-
-
                if (inputCreateUser.getMobile() != null)
                    newUserBuilder.setMobile(inputCreateUser.getMobile());
                newUserBuilder.setGender(inputCreateUser.getGender());
@@ -85,7 +78,7 @@ public class CreateUserAction extends AdminAction {


                try {
-                    messagesStore.addUserInfo(newUserBuilder.build(), inputCreateUser.getPassword());
+                    messagesStore.addUserInfo(newUserBuilder.build());
                } catch (Exception e) {
                    e.printStackTrace();
                    Utility.printExecption(LOG, e, IMExceptionEvent.EventType.ADMIN_API_Exception);
@@ -11,12 +11,17 @@ package com.xiaoleilu.loServer.action.admin;
 import cn.wildfirechat.common.APIPath;
 import cn.wildfirechat.common.ErrorCode;
 import cn.wildfirechat.pojos.InputUpdateFriendExtra;
+import cn.wildfirechat.proto.WFCMessage;
 import com.xiaoleilu.loServer.RestResult;
 import com.xiaoleilu.loServer.annotation.HttpMethod;
 import com.xiaoleilu.loServer.annotation.Route;
 import com.xiaoleilu.loServer.handler.Request;
 import com.xiaoleilu.loServer.handler.Response;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
 import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.util.internal.StringUtil;
+import win.liyufan.im.IMTopic;

@Route(APIPath.Friend_Set_Extra)
@HttpMethod("POST")
@@ -31,8 +36,17 @@ public class FriendExtraPutAction extends AdminAction {
    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputUpdateFriendExtra input = getRequestBody(request.getNettyRequest(), InputUpdateFriendExtra.class);
-            ErrorCode errorCode = messagesStore.setFriendExtraRequest(input.getOperator(), input.getTargetId(), input.getExtra(), new long[1]);
-            setResponseContent(RestResult.resultOf(errorCode), response);
+            if (input != null && !StringUtil.isNullOrEmpty(input.getOperator()) && !StringUtil.isNullOrEmpty(input.getTargetId())) {
+                sendApiMessage(response, input.getOperator(), IMTopic.SetFriendExtraTopic, WFCMessage.StringPair.newBuilder().setKey(input.getTargetId()).setValue(input.getExtra()==null?"":input.getExtra()).build().toByteArray(), result -> {
+                    ByteBuf byteBuf = Unpooled.buffer();
+                    byteBuf.writeBytes(result);
+                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
+                    return new Result(errorCode);
+                });
+                return false;
+            } else {
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
+            }
        }
        return true;
    }
@@ -0,0 +1,62 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.admin;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.*;
+import cn.wildfirechat.proto.WFCMessage;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.util.internal.StringUtil;
+
+import java.util.*;
+
+@Route(APIPath.User_Get_All_Robots)
+@HttpMethod("POST")
+public class GetAllRobotAction extends AdminAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            InputGetUserList input = getRequestBody(request.getNettyRequest(), InputGetUserList.class);
+            if (input != null && input.count > 0 && input.offset >= 0) {
+                List<WFCMessage.Robot> robots = messagesStore.getRobotInfoList(input.count, input.offset);
+
+                OutputGetRobotList outputGetUserList = new OutputGetRobotList();
+                outputGetUserList.robotInfoList = new ArrayList<>();
+                robots.forEach(robotData -> {
+                    WFCMessage.User userInfoData = messagesStore.getUserInfo(robotData.getUid());
+                    if (userInfoData != null && !StringUtil.isNullOrEmpty(userInfoData.getName()) && userInfoData.getDeleted() ==0) {
+                        OutputRobot outputRobot = new OutputRobot();
+                        outputRobot.fromUser(userInfoData);
+                        outputRobot.fromRobot(robotData, true);
+                        outputGetUserList.robotInfoList.add(outputRobot);
+                    }
+                });
+
+                RestResult result = RestResult.ok(outputGetUserList);
+                setResponseContent(result, response);
+            } else {
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
+            }
+
+        }
+        return true;
+    }
+}
@@ -0,0 +1,65 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.admin;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.PojoGroupInfo;
+import cn.wildfirechat.pojos.PojoGroupInfoList;
+import cn.wildfirechat.proto.WFCMessage;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.handler.codec.http.HttpResponseStatus;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Route(APIPath.Group_Batch_Info)
+@HttpMethod("POST")
+public class GetBatchGroupInfoAction extends AdminAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            List<String> inputGetGroup = getRequestBody(request.getNettyRequest(), ArrayList.class);
+            if (inputGetGroup != null && !inputGetGroup.isEmpty()) {
+                List<WFCMessage.UserRequest> requests = new ArrayList<>();
+                for (String s : inputGetGroup) {
+                    requests.add(WFCMessage.UserRequest.newBuilder().setUid(s).build());
+                }
+                List<WFCMessage.GroupInfo> groupInfoDataList = messagesStore.getGroupInfos(requests);
+                PojoGroupInfoList pojoGroupInfoList = new PojoGroupInfoList();
+                pojoGroupInfoList.groupInfoList = new ArrayList<>();
+
+                for (WFCMessage.GroupInfo groupInfo : groupInfoDataList) {
+                    pojoGroupInfoList.groupInfoList.add(PojoGroupInfo.fromProto(groupInfo));
+                }
+
+                response.setStatus(HttpResponseStatus.OK);
+                RestResult result = RestResult.ok(pojoGroupInfoList);
+                response.setContent(gson.toJson(result));
+            } else {
+                response.setStatus(HttpResponseStatus.OK);
+                RestResult result = RestResult.resultOf(ErrorCode.INVALID_PARAMETER);
+                response.setContent(gson.toJson(result));
+            }
+
+        }
+        return true;
+    }
+}
@@ -0,0 +1,61 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.admin;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.*;
+import cn.wildfirechat.proto.WFCMessage;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.handler.codec.http.HttpResponseStatus;
+import io.netty.util.internal.StringUtil;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+@Route(APIPath.User_Batch_Get_Infos)
+@HttpMethod("POST")
+public class GetBatchUserAction extends AdminAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            InputStringList inputUserId = getRequestBody(request.getNettyRequest(), InputStringList.class);
+            if (inputUserId != null && inputUserId.getList() != null && !inputUserId.getList().isEmpty()) {
+
+                OutputUserInfoList res = new OutputUserInfoList();
+                res.userInfos = new ArrayList<>();
+                for (String userId : inputUserId.getList()) {
+                    WFCMessage.User user = messagesStore.getUserInfo(userId);
+                    if(user == null || StringUtil.isNullOrEmpty(user.getName())) {
+                        continue;
+                    }
+                    InputOutputUserInfo inputOutputUserInfo = InputOutputUserInfo.fromPbUser(user);
+                    res.userInfos.add(inputOutputUserInfo);
+                }
+                RestResult result = RestResult.ok(res);
+                setResponseContent(result, response);
+            } else {
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
+            }
+        }
+        return true;
+    }
+}
@@ -0,0 +1,57 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.admin;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.InputCountOffset;
+import cn.wildfirechat.pojos.OutputChannelInfoList;
+import cn.wildfirechat.pojos.OutputGetChannelInfo;
+import cn.wildfirechat.proto.WFCMessage;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.util.internal.StringUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Route(APIPath.List_Channel_Info)
+@HttpMethod("POST")
+public class GetChannelListAction extends AdminAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            InputCountOffset inputCreateChannel = getRequestBody(request.getNettyRequest(), InputCountOffset.class);
+            if (inputCreateChannel != null
+                && inputCreateChannel.count > 0 && inputCreateChannel.offset >= 0) {
+                int count = messagesStore.getChannelTotalCount(false);
+                List<WFCMessage.ChannelInfo> list = messagesStore.getChannelInfoList(inputCreateChannel.count, inputCreateChannel.offset, false);
+                OutputChannelInfoList outputChannelInfoList = new OutputChannelInfoList();
+                outputChannelInfoList.total = count;
+                outputChannelInfoList.list = new ArrayList<>();
+                for (WFCMessage.ChannelInfo channelData : list) {
+                    outputChannelInfoList.list.add(OutputGetChannelInfo.fromPbInfo(channelData));
+                }
+                sendResponse(response, ErrorCode.ERROR_CODE_SUCCESS, outputChannelInfoList);
+            } else {
+                sendResponse(response, ErrorCode.INVALID_PARAMETER, null);
+            }
+        }
+        return true;
+    }
+}
@@ -46,21 +46,7 @@ public class GetGroupInfoAction extends AdminAction {
                if (groupInfo == null) {
                    result = RestResult.resultOf(ErrorCode.ERROR_CODE_NOT_EXIST);
                } else {
-                    PojoGroupInfo pojoGroupInfo = new PojoGroupInfo();
-                    pojoGroupInfo.setExtra(groupInfo.getExtra());
-                    pojoGroupInfo.setName(groupInfo.getName());
-                    pojoGroupInfo.setOwner(groupInfo.getOwner());
-                    pojoGroupInfo.setPortrait(groupInfo.getPortrait());
-                    pojoGroupInfo.setTarget_id(groupInfo.getTargetId());
-                    pojoGroupInfo.setType(groupInfo.getType());
-                    pojoGroupInfo.setMute(groupInfo.getMute());
-                    pojoGroupInfo.setJoin_type(groupInfo.getJoinType());
-                    pojoGroupInfo.setPrivate_chat(groupInfo.getPrivateChat());
-                    pojoGroupInfo.setSearchable(groupInfo.getSearchable());
-                    pojoGroupInfo.setMax_member_count(groupInfo.getMemberCount());
-                    pojoGroupInfo.setHistory_message(groupInfo.getHistoryMessage());
-                    pojoGroupInfo.setSuper_group(groupInfo.getSuperGroup()>0);
-                    result = RestResult.ok(pojoGroupInfo);
+                    result = RestResult.ok(PojoGroupInfo.fromProto(groupInfo));
                }
                setResponseContent(result, response);
            } else {
@@ -20,6 +20,7 @@ import io.netty.handler.codec.http.FullHttpRequest;
 import cn.wildfirechat.common.ErrorCode;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import win.liyufan.im.GitRepositoryState;
 import win.liyufan.im.IMTopic;

 import java.util.Base64;
@@ -53,7 +54,7 @@ public class GetIMTokenAction extends AdminAction {

                    LOG.info("get im token success {},{},{}", userId, input.getClientId(), token.substring(0, Math.min(10, token.length())));
                    
-                    return new Result(errorCode1, new OutputGetIMTokenData(userId, token));
+                    return new Result(errorCode1, new OutputGetIMTokenData(userId, token, GitRepositoryState.globalLabel));
                } else {
                    return new Result(errorCode1);
                }
@@ -0,0 +1,126 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.admin;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.InputGetPresignedUploadUrl;
+import cn.wildfirechat.pojos.OutputPresignedUploadUrl;
+import com.qiniu.util.Auth;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.action.robot.RobotAction;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.moquette.server.config.MediaServerConfig;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.util.internal.StringUtil;
+
+import java.util.UUID;
+
+@Route(APIPath.Get_Presigned_Upload_Url)
+@HttpMethod("POST")
+public class GetUploadUrlAction extends AdminAction {
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            if(!MediaServerConfig.USER_QINIU) {
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
+                return true;
+            }
+
+            InputGetPresignedUploadUrl inputUserId = getRequestBody(request.getNettyRequest(), InputGetPresignedUploadUrl.class);
+
+            if (StringUtil.isNullOrEmpty(inputUserId.contentType)) {
+                inputUserId.contentType = "application/octet-stream";
+            }
+            String uuid = UUID.randomUUID().toString().replace("-", "");
+            inputUserId.fileName = uuid + inputUserId.fileName;
+
+            int type = inputUserId.mediaType;
+            String bucketName;
+            String bucketDomain;
+            switch (type) {
+                case 0:
+                default:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_GENERAL_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_GENERAL_DOMAIN;
+                    break;
+                case 1:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_IMAGE_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_IMAGE_DOMAIN;
+                    break;
+                case 2:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_VOICE_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_VOICE_DOMAIN;
+                    break;
+                case 3:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_VIDEO_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_VIDEO_DOMAIN;
+                    break;
+                case 4:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_FILE_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_FILE_DOMAIN;
+                    break;
+                case 5:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_PORTRAIT_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_PORTRAIT_DOMAIN;
+                    break;
+                case 6:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_FAVORITE_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_FAVORITE_DOMAIN;
+                    break;
+                case 7:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_STICKER_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_STICKER_DOMAIN;
+                    break;
+                case 8:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_MOMENTS_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_MOMENTS_DOMAIN;
+                    break;
+                case 9:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_CUSTOM1_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_CUSTOM1_DOMAIN;
+                    break;
+                case 10:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_CUSTOM2_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_CUSTOM2_DOMAIN;
+                    break;
+                case 11:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_CUSTOM3_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_CUSTOM3_DOMAIN;
+                    break;
+                case 12:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_PAN_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_PAN_DOMAIN;
+                    break;
+            }
+
+            if(StringUtil.isNullOrEmpty(bucketName)) {
+                bucketName = MediaServerConfig.QINIU_BUCKET_GENERAL_NAME;
+                bucketDomain = MediaServerConfig.QINIU_BUCKET_GENERAL_DOMAIN;
+            }
+
+            String key = inputUserId.fileName;
+            Auth auth = Auth.create(MediaServerConfig.QINIU_ACCESS_KEY, MediaServerConfig.QINIU_SECRET_KEY);
+            String token = auth.uploadToken(bucketName, key);
+            String downloadUrl = bucketDomain + "/" + key;
+            String uploadUrl = "https://" + MediaServerConfig.QINIU_SERVER_URL + "?" + token + "?" + key;
+
+            OutputPresignedUploadUrl outputPresignedUploadUrl = new OutputPresignedUploadUrl();
+            outputPresignedUploadUrl.uploadUrl = uploadUrl;
+            outputPresignedUploadUrl.downloadUrl = downloadUrl;
+            outputPresignedUploadUrl.type = 1;
+            setResponseContent(RestResult.ok(outputPresignedUploadUrl), response);
+        }
+        return true;
+    }
+}
@@ -49,7 +49,7 @@ public class GetUserAction extends AdminAction {
                }

                RestResult result;
-                if (user == null || user.getDeleted() > 0) {
+                if (user == null || (user.getDeleted() > 0 && !inputUserId.isIncludeDeleted())) {
                    result = RestResult.resultOf(ErrorCode.ERROR_CODE_NOT_EXIST);
                } else {
                    result = RestResult.ok(InputOutputUserInfo.fromPbUser(user));
@@ -0,0 +1,49 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.admin;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.InputRobotId;
+import cn.wildfirechat.pojos.InputUserId;
+import cn.wildfirechat.pojos.OutputRobot;
+import cn.wildfirechat.pojos.OutputStringList;
+import cn.wildfirechat.proto.WFCMessage;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.util.internal.StringUtil;
+
+@Route(APIPath.User_Get_User_Robots)
+@HttpMethod("POST")
+public class GetUserRobotsAction extends AdminAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            InputUserId inputUserId = getRequestBody(request.getNettyRequest(), InputUserId.class);
+            if (inputUserId != null
+                && (!StringUtil.isNullOrEmpty(inputUserId.getUserId()))) {
+                RestResult result = RestResult.ok(new OutputStringList(messagesStore.getUserRobotIds(inputUserId.getUserId())));
+                setResponseContent(result, response);
+            } else {
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
+            }
+        }
+        return true;
+    }
+}
@@ -0,0 +1,66 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.admin;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.InputGetUserInfo;
+import cn.wildfirechat.pojos.InputOutputUserInfo;
+import cn.wildfirechat.pojos.OutputUserInfoList;
+import cn.wildfirechat.proto.WFCMessage;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.util.internal.StringUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Route(APIPath.User_Get_Email_Info)
+@HttpMethod("POST")
+public class GetUsersByEmailAction extends AdminAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            String email = getRequestBody(request.getNettyRequest(), String.class);
+            if (!StringUtil.isNullOrEmpty(email)) {
+
+                List<WFCMessage.User> users = messagesStore.getUserInfosByEmail(email);
+                List<InputOutputUserInfo> list = new ArrayList<>();
+                for (WFCMessage.User user : users) {
+                    list.add(InputOutputUserInfo.fromPbUser(user));
+                }
+
+                RestResult result;
+                if (list.isEmpty()) {
+                    result = RestResult.resultOf(ErrorCode.ERROR_CODE_NOT_EXIST);
+                } else {
+                    OutputUserInfoList outputUserInfoList = new OutputUserInfoList();
+                    outputUserInfoList.userInfos = list;
+                    result = RestResult.ok(outputUserInfoList);
+                }
+
+                setResponseContent(result, response);
+            } else {
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
+            }
+
+        }
+        return true;
+    }
+}
@@ -0,0 +1,65 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.admin;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.InputGetUserInfo;
+import cn.wildfirechat.pojos.InputOutputUserInfo;
+import cn.wildfirechat.pojos.OutputUserInfoList;
+import cn.wildfirechat.proto.WFCMessage;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.util.internal.StringUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Route(APIPath.User_Get_By_Mobile)
+@HttpMethod("POST")
+public class GetUsersByMobileAction extends AdminAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            InputGetUserInfo email = getRequestBody(request.getNettyRequest(), InputGetUserInfo.class);
+            if (!StringUtil.isNullOrEmpty(email.getMobile())) {
+                List<WFCMessage.User> users = messagesStore.getUserInfosByMobile(email.getMobile(), email.isIncludeDeleted());
+                List<InputOutputUserInfo> list = new ArrayList<>();
+                for (WFCMessage.User user : users) {
+                    list.add(InputOutputUserInfo.fromPbUser(user));
+                }
+
+                RestResult result;
+                if (list.isEmpty()) {
+                    result = RestResult.resultOf(ErrorCode.ERROR_CODE_NOT_EXIST);
+                } else {
+                    OutputUserInfoList outputUserInfoList = new OutputUserInfoList();
+                    outputUserInfoList.userInfos = list;
+                    result = RestResult.ok(outputUserInfoList);
+                }
+
+                setResponseContent(result, response);
+            } else {
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
+            }
+
+        }
+        return true;
+    }
+}
@@ -0,0 +1,49 @@
+package com.xiaoleilu.loServer.action.admin;
+
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.InputStringCountOffset;
+import cn.wildfirechat.pojos.InputSubscribeChannel;
+import cn.wildfirechat.pojos.OutputBooleanValue;
+import cn.wildfirechat.pojos.PojoTotalList;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.handler.codec.http.HttpResponseStatus;
+import io.netty.util.internal.StringUtil;
+
+import java.util.List;
+
+@Route(APIPath.List_Channel_Subscriber)
+@HttpMethod("POST")
+public class ListChannelSubscriberAction extends AdminAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            InputStringCountOffset inputSubscribeChannel = getRequestBody(request.getNettyRequest(), InputStringCountOffset.class);
+            response.setStatus(HttpResponseStatus.OK);
+            if (inputSubscribeChannel != null
+                && !StringUtil.isNullOrEmpty(inputSubscribeChannel.target)
+                && inputSubscribeChannel.count > 0) {
+                int count = messagesStore.getChannelListenerCount(inputSubscribeChannel.target);
+                List<String> list = messagesStore.getChannelListenerList(inputSubscribeChannel.target, inputSubscribeChannel.count, inputSubscribeChannel.offset);
+                RestResult result = RestResult.ok(new PojoTotalList(count, list));
+                response.setContent(gson.toJson(result));
+            } else {
+                RestResult result = RestResult.resultOf(ErrorCode.INVALID_PARAMETER);
+                response.setContent(gson.toJson(result));
+            }
+        }
+        return true;
+    }
+}
@@ -51,7 +51,7 @@ public class SendMessageAction extends AdminAction {
                    } else {
                        return new Result(errorCode);
                    }
-                });
+                }, sendMessageData.isUserMessage());
                return false;
            } else {
                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
@@ -0,0 +1,53 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.admin;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.InputChatroomMute;
+
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.handler.codec.http.HttpResponseStatus;
+import io.netty.util.internal.StringUtil;
+
+@Route(APIPath.Chatroom_MuteAll)
+@HttpMethod("POST")
+public class SetChatroomMuteAction extends AdminAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            InputChatroomMute input = getRequestBody(request.getNettyRequest(), InputChatroomMute.class);
+            if (input != null
+                && !StringUtil.isNullOrEmpty(input.getChatroomId())) {
+
+                ErrorCode code = messagesStore.setChatroomState(input.getChatroomId(), input.getStatus());
+                response.setStatus(HttpResponseStatus.OK);
+                response.setContent(gson.toJson(RestResult.resultOf(code)));
+                sendResponse(response, ErrorCode.ERROR_CODE_SUCCESS, null);
+            } else {
+                response.setStatus(HttpResponseStatus.OK);
+                RestResult result = RestResult.resultOf(ErrorCode.INVALID_PARAMETER);
+                response.setContent(gson.toJson(result));
+            }
+
+        }
+        return true;
+    }
+}
@@ -0,0 +1,57 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.admin;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.UserSettingPojo;
+import cn.wildfirechat.proto.WFCMessage;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.handler.codec.http.HttpResponseStatus;
+import io.netty.util.internal.StringUtil;
+
+@Route(APIPath.User_Get_Setting)
+@HttpMethod("POST")
+public class UserSettingGetAction extends AdminAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            UserSettingPojo input = getRequestBody(request.getNettyRequest(), UserSettingPojo.class);
+            if (input != null && (!StringUtil.isNullOrEmpty(input.getUserId()))) {
+                WFCMessage.UserSettingEntry entry = messagesStore.getUserSetting(input.getUserId(), input.getScope(), input.getKey());
+                response.setStatus(HttpResponseStatus.OK);
+                RestResult result;
+                if (entry == null) {
+                    result = RestResult.resultOf(ErrorCode.ERROR_CODE_NOT_EXIST);
+                } else {
+                    input.setValue(entry.getValue());
+                    result = RestResult.ok(input);
+                }
+                response.setContent(gson.toJson(result));
+            } else {
+                response.setStatus(HttpResponseStatus.OK);
+                RestResult result = RestResult.resultOf(ErrorCode.INVALID_PARAMETER);
+                response.setContent(gson.toJson(result));
+            }
+
+        }
+        return true;
+    }
+}
@@ -0,0 +1,60 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.admin;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.UserSettingPojo;
+import cn.wildfirechat.proto.ProtoConstants;
+import cn.wildfirechat.proto.WFCMessage;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.handler.codec.http.HttpResponseStatus;
+import io.netty.util.internal.StringUtil;
+
+import static win.liyufan.im.IMTopic.PutUserSettingTopic;
+import static win.liyufan.im.UserSettingScope.kUserSettingMyChannels;
+
+@Route(APIPath.User_Put_Setting)
+@HttpMethod("POST")
+public class UserSettingPutAction extends AdminAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            UserSettingPojo userSettingPojo = getRequestBody(request.getNettyRequest(), UserSettingPojo.class);
+            if (userSettingPojo != null && !StringUtil.isNullOrEmpty(userSettingPojo.getUserId())) {
+                WFCMessage.ModifyUserSettingReq modifyUserSettingReq = WFCMessage.ModifyUserSettingReq.newBuilder().setScope(userSettingPojo.getScope()).setKey(userSettingPojo.getKey()).setValue(userSettingPojo.getValue()).build();
+                sendApiMessage(response, userSettingPojo.getUserId(), PutUserSettingTopic, modifyUserSettingReq.toByteArray(), result -> {
+                    ByteBuf byteBuf = Unpooled.buffer();
+                    byteBuf.writeBytes(result);
+                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
+                    return new Result(errorCode);
+                });
+                return false;
+            } else {
+                response.setStatus(HttpResponseStatus.OK);
+                RestResult result = RestResult.resultOf(ErrorCode.INVALID_PARAMETER);
+                response.setContent(gson.toJson(result));
+            }
+        }
+        return true;
+    }
+}
@@ -105,18 +105,6 @@ abstract public class ChannelAction extends Action {
        response.send();
    }

-    protected <T> T getRequestBody(HttpRequest request, Class<T> cls) {
-        if (request instanceof FullHttpRequest) {
-            FullHttpRequest fullHttpRequest = (FullHttpRequest) request;
-            byte[] bytes = Utils.readBytesAndRewind(fullHttpRequest.content());
-            String content = new String(bytes, StandardCharsets.UTF_8);
-            
-            T t = gson.fromJson(content, cls);
-            return t;
-        }
-        return null;
-    }
-
    protected void sendApiMessage(Response response, String topic, byte[] message, Callback callback) {
        sendApiMessage(response, channelInfo.getOwner(), topic, message, callback);
    }
@@ -0,0 +1,87 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.robot;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.InputOutputUserInfo;
+import cn.wildfirechat.pojos.InputStringList;
+import cn.wildfirechat.pojos.OutputUserInfoList;
+import cn.wildfirechat.proto.WFCMessage;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.util.internal.StringUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Route(APIPath.Robot_User_Batch_Get_Infos)
+@HttpMethod("POST")
+public class GetBatchUserAction extends RobotAction {
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            InputStringList inputUserId = getRequestBody(request.getNettyRequest(), InputStringList.class);
+            if (inputUserId != null && inputUserId.getList() != null && !inputUserId.getList().isEmpty()) {
+
+                OutputUserInfoList res = new OutputUserInfoList();
+                res.userInfos = new ArrayList<>();
+                int mask = messagesStore.getRobotGetUserInfoMask();
+                for (String userId : inputUserId.getList()) {
+                    WFCMessage.User user = messagesStore.getUserInfo(userId);
+                    if(user == null || StringUtil.isNullOrEmpty(user.getName())) {
+                        continue;
+                    }
+                    InputOutputUserInfo inputOutputUserInfo = InputOutputUserInfo.fromPbUser(user);
+                    if((mask & 1) == 0) {
+                        inputOutputUserInfo.setName(null);
+                    }
+                    if((mask & 2) == 0) {
+                        inputOutputUserInfo.setMobile(null);
+                    }
+                    if((mask & 4) == 0) {
+                        inputOutputUserInfo.setEmail(null);
+                    }
+                    if((mask & 8) == 0) {
+                        inputOutputUserInfo.setAddress(null);
+                    }
+                    if((mask & 16) == 0) {
+                        inputOutputUserInfo.setCompany(null);
+                    }
+                    if((mask & 32) == 0) {
+                        inputOutputUserInfo.setExtra(null);
+                    }
+                    if((mask & 64) == 0) {
+                        inputOutputUserInfo.setUpdateDt(0);
+                    }
+                    if((mask & 128) == 0) {
+                        inputOutputUserInfo.setGender(0);
+                    }
+                    if((mask & 256) == 0) {
+                        inputOutputUserInfo.setSocial(null);
+                    }
+                    if((mask & 512) == 0) {
+                        inputOutputUserInfo.setType(0);
+                    }
+                    res.userInfos.add(inputOutputUserInfo);
+                }
+                RestResult result = RestResult.ok(res);
+                setResponseContent(result, response);
+            } else {
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
+            }
+        }
+        return true;
+    }
+}
@@ -52,10 +52,17 @@ public class GetGroupInfoAction extends RobotAction {
                    pojoGroupInfo.setPortrait(groupInfo.getPortrait());
                    pojoGroupInfo.setTarget_id(groupInfo.getTargetId());
                    pojoGroupInfo.setType(groupInfo.getType());
+                    pojoGroupInfo.setMember_count(groupInfo.getMemberCount());
                    pojoGroupInfo.setMute(groupInfo.getMute());
                    pojoGroupInfo.setJoin_type(groupInfo.getJoinType());
                    pojoGroupInfo.setPrivate_chat(groupInfo.getPrivateChat());
                    pojoGroupInfo.setSearchable(groupInfo.getSearchable());
+                    pojoGroupInfo.setMax_member_count(groupInfo.getMemberCount());
+                    pojoGroupInfo.setHistory_message(groupInfo.getHistoryMessage());
+                    pojoGroupInfo.setSuper_group(groupInfo.getSuperGroup()>0);
+                    pojoGroupInfo.setDeleted(groupInfo.getDeleted()>0);
+                    pojoGroupInfo.setUpdate_dt(groupInfo.getUpdateDt());
+                    pojoGroupInfo.setMember_update_dt(groupInfo.getMemberUpdateDt());
                    result = RestResult.ok(pojoGroupInfo);
                }
                setResponseContent(result, response);
@@ -0,0 +1,139 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.robot;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.InputGetPresignedUploadUrl;
+import cn.wildfirechat.pojos.InputGetUserInfo;
+import cn.wildfirechat.pojos.InputOutputUserInfo;
+import cn.wildfirechat.pojos.OutputPresignedUploadUrl;
+import cn.wildfirechat.proto.ProtoConstants;
+import cn.wildfirechat.proto.WFCMessage;
+import com.qiniu.util.Auth;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.moquette.persistence.MemorySessionStore;
+import io.moquette.server.config.MediaServerConfig;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.util.internal.StringUtil;
+
+import javax.crypto.Mac;
+import javax.crypto.spec.SecretKeySpec;
+import java.io.IOException;
+import java.net.URL;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.time.ZonedDateTime;
+import java.util.*;
+
+@Route(APIPath.Robot_Get_Presigned_Upload_Url)
+@HttpMethod("POST")
+public class GetUploadUrlAction extends RobotAction {
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            if(!MediaServerConfig.USER_QINIU) {
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
+                return true;
+            }
+
+            InputGetPresignedUploadUrl inputUserId = getRequestBody(request.getNettyRequest(), InputGetPresignedUploadUrl.class);
+
+            if (StringUtil.isNullOrEmpty(inputUserId.contentType)) {
+                inputUserId.contentType = "application/octet-stream";
+            }
+            String uuid = UUID.randomUUID().toString().replace("-", "");
+            inputUserId.fileName = uuid + inputUserId.fileName;
+
+            int type = inputUserId.mediaType;
+            String bucketName;
+            String bucketDomain;
+            switch (type) {
+                case 0:
+                default:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_GENERAL_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_GENERAL_DOMAIN;
+                    break;
+                case 1:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_IMAGE_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_IMAGE_DOMAIN;
+                    break;
+                case 2:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_VOICE_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_VOICE_DOMAIN;
+                    break;
+                case 3:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_VIDEO_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_VIDEO_DOMAIN;
+                    break;
+                case 4:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_FILE_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_FILE_DOMAIN;
+                    break;
+                case 5:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_PORTRAIT_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_PORTRAIT_DOMAIN;
+                    break;
+                case 6:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_FAVORITE_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_FAVORITE_DOMAIN;
+                    break;
+                case 7:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_STICKER_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_STICKER_DOMAIN;
+                    break;
+                case 8:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_MOMENTS_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_MOMENTS_DOMAIN;
+                    break;
+                case 9:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_CUSTOM1_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_CUSTOM1_DOMAIN;
+                    break;
+                case 10:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_CUSTOM2_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_CUSTOM2_DOMAIN;
+                    break;
+                case 11:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_CUSTOM3_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_CUSTOM3_DOMAIN;
+                    break;
+                case 12:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_PAN_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_PAN_DOMAIN;
+                    break;
+            }
+
+            if(StringUtil.isNullOrEmpty(bucketName)) {
+                bucketName = MediaServerConfig.QINIU_BUCKET_GENERAL_NAME;
+                bucketDomain = MediaServerConfig.QINIU_BUCKET_GENERAL_DOMAIN;
+            }
+
+            String key = inputUserId.fileName;
+            Auth auth = Auth.create(MediaServerConfig.QINIU_ACCESS_KEY, MediaServerConfig.QINIU_SECRET_KEY);
+            String token = auth.uploadToken(bucketName, key);
+            String downloadUrl = bucketDomain + "/" + key;
+            String uploadUrl = "https://" + MediaServerConfig.QINIU_SERVER_URL + "?" + token + "?" + key;
+
+            OutputPresignedUploadUrl outputPresignedUploadUrl = new OutputPresignedUploadUrl();
+            outputPresignedUploadUrl.uploadUrl = uploadUrl;
+            outputPresignedUploadUrl.downloadUrl = downloadUrl;
+            outputPresignedUploadUrl.type = 1;
+            setResponseContent(RestResult.ok(outputPresignedUploadUrl), response);
+        }
+        return true;
+    }
+}
@@ -47,7 +47,39 @@ public class GetUserAction extends RobotAction {
                if (user == null || user.getDeleted() > 0) {
                    result = RestResult.resultOf(ErrorCode.ERROR_CODE_NOT_EXIST);
                } else {
-                    result = RestResult.ok(InputOutputUserInfo.fromPbUser(user));
+                    InputOutputUserInfo outputUserInfo = InputOutputUserInfo.fromPbUser(user);
+                    int mask = messagesStore.getRobotGetUserInfoMask();
+                    if((mask & 1) == 0) {
+                        outputUserInfo.setName(null);
+                    }
+                    if((mask & 2) == 0) {
+                        outputUserInfo.setMobile(null);
+                    }
+                    if((mask & 4) == 0) {
+                        outputUserInfo.setEmail(null);
+                    }
+                    if((mask & 8) == 0) {
+                        outputUserInfo.setAddress(null);
+                    }
+                    if((mask & 16) == 0) {
+                        outputUserInfo.setCompany(null);
+                    }
+                    if((mask & 32) == 0) {
+                        outputUserInfo.setExtra(null);
+                    }
+                    if((mask & 64) == 0) {
+                        outputUserInfo.setUpdateDt(0);
+                    }
+                    if((mask & 128) == 0) {
+                        outputUserInfo.setGender(0);
+                    }
+                    if((mask & 256) == 0) {
+                        outputUserInfo.setSocial(null);
+                    }
+                    if((mask & 512) == 0) {
+                        outputUserInfo.setType(0);
+                    }
+                    result = RestResult.ok(outputUserInfo);
                }
                setResponseContent(result, response);
            } else {
@@ -0,0 +1,92 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.robot;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.InputOutputUserInfo;
+import cn.wildfirechat.pojos.OutputUserInfoList;
+import cn.wildfirechat.proto.WFCMessage;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.util.internal.StringUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Route(APIPath.Robot_User_Get_Email_Info)
+@HttpMethod("POST")
+public class GetUsersByEmailAction extends RobotAction {
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            String email = getRequestBody(request.getNettyRequest(), String.class);
+            if (!StringUtil.isNullOrEmpty(email)) {
+
+                List<WFCMessage.User> users = messagesStore.getUserInfosByEmail(email);
+                List<InputOutputUserInfo> list = new ArrayList<>();
+                int mask = messagesStore.getRobotGetUserInfoMask();
+                for (WFCMessage.User user : users) {
+                    InputOutputUserInfo outputUserInfo = InputOutputUserInfo.fromPbUser(user);
+                    if((mask & 1) == 0) {
+                        outputUserInfo.setName(null);
+                    }
+                    if((mask & 2) == 0) {
+                        outputUserInfo.setMobile(null);
+                    }
+                    if((mask & 4) == 0) {
+                        outputUserInfo.setEmail(null);
+                    }
+                    if((mask & 8) == 0) {
+                        outputUserInfo.setAddress(null);
+                    }
+                    if((mask & 16) == 0) {
+                        outputUserInfo.setCompany(null);
+                    }
+                    if((mask & 32) == 0) {
+                        outputUserInfo.setExtra(null);
+                    }
+                    if((mask & 64) == 0) {
+                        outputUserInfo.setUpdateDt(0);
+                    }
+                    if((mask & 128) == 0) {
+                        outputUserInfo.setGender(0);
+                    }
+                    if((mask & 256) == 0) {
+                        outputUserInfo.setSocial(null);
+                    }
+                    if((mask & 512) == 0) {
+                        outputUserInfo.setType(0);
+                    }
+                    list.add(outputUserInfo);
+                }
+
+                RestResult result;
+                if (list.isEmpty()) {
+                    result = RestResult.resultOf(ErrorCode.ERROR_CODE_NOT_EXIST);
+                } else {
+                    OutputUserInfoList outputUserInfoList = new OutputUserInfoList();
+                    outputUserInfoList.userInfos = list;
+                    result = RestResult.ok(outputUserInfoList);
+                }
+
+                setResponseContent(result, response);
+            } else {
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
+            }
+
+        }
+        return true;
+    }
+}
@@ -0,0 +1,112 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.robot;
+
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.Conversation;
+import cn.wildfirechat.pojos.ReplyMessageData;
+import cn.wildfirechat.pojos.SendMessageData;
+import cn.wildfirechat.pojos.SendMessageResult;
+import cn.wildfirechat.proto.ProtoConstants;
+import cn.wildfirechat.proto.WFCMessage;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.handler.codec.http.HttpResponseStatus;
+import org.jetbrains.annotations.NotNull;
+import win.liyufan.im.IMTopic;
+
+import java.util.Arrays;
+
+@Route(APIPath.Robot_Message_Reply)
+@HttpMethod("POST")
+public class ReplyMessageAction extends RobotAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            ReplyMessageData replyMessageData = getRequestBody(request.getNettyRequest(), ReplyMessageData.class);
+            if (ReplyMessageData.isValide(replyMessageData)) {
+                WFCMessage.Message message = messagesStore.getMessage(replyMessageData.getMessageUid());
+                ErrorCode errorCode = null;
+                if(message == null) {
+                    errorCode = ErrorCode.ERROR_CODE_NOT_EXIST;
+                } else if(!message.getContent().getMentionedTargetList().contains(robot.getUid())) {
+                    errorCode = ErrorCode.ERROR_CODE_INVALID_MESSAGE;
+                } else if(message.getConversation().getType() != ProtoConstants.ConversationType.ConversationType_Private && message.getConversation().getType() != ProtoConstants.ConversationType.ConversationType_Group) {
+                    errorCode = ErrorCode.ERROR_CODE_NOT_IMPLEMENT;
+                } else if(System.currentTimeMillis() - message.getServerTimestamp() > 15*60*1000) {
+                    errorCode = ErrorCode.ERROR_CODE_RECALL_TIME_EXPIRED;
+                } else if(!messagesStore.isRobotMentionExternalRobot()) {
+                    if(message.getConversation().getType() != ProtoConstants.ConversationType.ConversationType_Group) {
+                        errorCode = ErrorCode.ERROR_CODE_NOT_IMPLEMENT;
+                    } else {
+                        WFCMessage.GroupMember member = messagesStore.getGroupMember(message.getConversation().getTarget(), robot.getUid());
+                        if(member == null || member.getType() == ProtoConstants.GroupMemberType.GroupMemberType_Removed) {
+                            errorCode = ErrorCode.ERROR_CODE_NOT_IMPLEMENT;
+                        }
+                    }
+                }
+
+                if(errorCode != null) {
+                    response.setStatus(HttpResponseStatus.OK);
+                    RestResult result = RestResult.resultOf(errorCode);
+                    response.setContent(gson.toJson(result));
+                    return true;
+                }
+
+                SendMessageData sendMessageData = getSendMessageData(message, replyMessageData);
+                WFCMessage.Message newMsg = sendMessageData.toProtoMessage().toBuilder().setMessageId(message.getMessageId()).build();
+                sendApiRequest(response, IMTopic.RobotReplyMessageTopic, newMsg.toByteArray(), result -> {
+                    ByteBuf byteBuf = Unpooled.buffer();
+                    byteBuf.writeBytes(result);
+                    ErrorCode ec = ErrorCode.fromCode(byteBuf.readByte());
+                    if (ec == ErrorCode.ERROR_CODE_SUCCESS) {
+                        long messageId = byteBuf.readLong();
+                        long timestamp = byteBuf.readLong();
+                        sendResponse(response, null, new SendMessageResult(messageId, timestamp));
+                    } else {
+                        sendResponse(response, ec, null);
+                    }
+                });
+                return false;
+            } else {
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
+            }
+        }
+        return true;
+    }
+
+    private @NotNull SendMessageData getSendMessageData(WFCMessage.Message message, ReplyMessageData replyMessageData) {
+        SendMessageData sendMessageData = new SendMessageData();
+        sendMessageData.setSender(robot.getUid());
+        Conversation conversation = new Conversation();
+        conversation.setType(message.getConversation().getType());
+        conversation.setLine(message.getConversation().getLine());
+        conversation.setTarget(message.getConversation().getTarget());
+        sendMessageData.setConv(conversation);
+        sendMessageData.setPayload(replyMessageData.getPayload());
+        if(replyMessageData.isOnly2Sender()) {
+            sendMessageData.setToUsers(Arrays.asList(message.getFromUser()));
+        }
+        return sendMessageData;
+    }
+}
@@ -106,24 +106,6 @@ abstract public class RobotAction extends Action {
        response.send();
    }

-    protected <T> T getRequestBody(HttpRequest request, Class<T> cls) {
-        if (request instanceof FullHttpRequest) {
-            FullHttpRequest fullHttpRequest = (FullHttpRequest) request;
-            byte[] bytes = Utils.readBytesAndRewind(fullHttpRequest.content());
-            String content = null;
-            try {
-                content = new String(bytes, "UTF-8");
-                
-                T t = gson.fromJson(content, cls);
-                return t;
-            } catch (UnsupportedEncodingException e) {
-                e.printStackTrace();
-                Utility.printExecption(LOG, e, IMExceptionEvent.EventType.ROBOT_API_Exception);
-            }
-        }
-        return null;
-    }
-
    protected void sendApiRequest(Response response, String topic, byte[] message, Callback callback) {
        ServerAPIHelper.sendRequest(robot.getUid(), null, topic, message, new ServerAPIHelper.Callback() {
            @Override
@@ -80,6 +80,7 @@ public class UpdateProfileAction extends RobotAction {
            RestResult result = RestResult.ok();
            if(modified) {
                try {
+                    builder.setUpdateDt(System.currentTimeMillis());
                    messagesStore.updateUserInfo(builder.build());
                } catch (Exception e) {
                    e.printStackTrace();
@@ -1,31 +1,32 @@
-package com.xiaoleilu.loServer.exception;
-
-import com.xiaoleilu.hutool.util.StrUtil;
-
-/**
- * 设置异常
- * @author xiaoleilu
- */
-public class ServerSettingException extends RuntimeException{
-	private static final long serialVersionUID = -4134588858314744501L;
-
-	public ServerSettingException(Throwable e) {
-		super(e);
-	}
-	
-	public ServerSettingException(String message) {
-		super(message);
-	}
-	
-	public ServerSettingException(String messageTemplate, Object... params) {
-		super(StrUtil.format(messageTemplate, params));
-	}
-	
-	public ServerSettingException(String message, Throwable throwable) {
-		super(message, throwable);
-	}
-	
-	public ServerSettingException(Throwable throwable, String messageTemplate, Object... params) {
-		super(StrUtil.format(messageTemplate, params), throwable);
-	}
-}
+package com.xiaoleilu.loServer.exception;
+
+
+import cn.hutool.core.util.StrUtil;
+
+/**
+ * 设置异常
+ * @author xiaoleilu
+ */
+public class ServerSettingException extends RuntimeException{
+	private static final long serialVersionUID = -4134588858314744501L;
+
+	public ServerSettingException(Throwable e) {
+		super(e);
+	}
+	
+	public ServerSettingException(String message) {
+		super(message);
+	}
+	
+	public ServerSettingException(String messageTemplate, Object... params) {
+		super(StrUtil.format(messageTemplate, params));
+	}
+	
+	public ServerSettingException(String message, Throwable throwable) {
+		super(message, throwable);
+	}
+	
+	public ServerSettingException(Throwable throwable, String messageTemplate, Object... params) {
+		super(StrUtil.format(messageTemplate, params), throwable);
+	}
+}
@@ -1,7 +1,7 @@
 package com.xiaoleilu.loServer.handler;

+import cn.hutool.core.lang.Singleton;
 import cn.wildfirechat.common.IMExceptionEvent;
-import com.xiaoleilu.hutool.lang.Singleton;
 import com.xiaoleilu.loServer.ServerSetting;
 import com.xiaoleilu.loServer.action.Action;
 import com.xiaoleilu.loServer.action.UnknownErrorAction;
@@ -8,7 +8,6 @@

 package com.xiaoleilu.loServer.handler;

-import com.xiaoleilu.hutool.lang.Singleton;
 import com.xiaoleilu.loServer.ServerSetting;
 import com.xiaoleilu.loServer.action.Action;
 import com.xiaoleilu.loServer.action.FileAction;
@@ -1,28 +1,27 @@
-package com.xiaoleilu.loServer.handler;
-
-import com.xiaoleilu.hutool.log.StaticLog;
-
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.ChannelPromise;
-import io.netty.channel.FileRegion;
-import io.netty.handler.codec.http.DefaultHttpResponse;
-import io.netty.handler.codec.http.HttpContentCompressor;
-
-/**
- * 解决大文件传输与Gzip压缩冲突问题
- * @author Looly
- *
- */
-public class HttpChunkContentCompressor extends HttpContentCompressor {
-	@Override
-	public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
-		StaticLog.debug("Write object [{}]", msg);
-		
-		if (msg instanceof FileRegion || msg instanceof DefaultHttpResponse) {
-			//文件传输不经过Gzip压缩
-			ctx.write(msg, promise);
-		}else{
-			super.write(ctx, msg, promise);
-		}
-	}
-}
+package com.xiaoleilu.loServer.handler;
+
+import cn.hutool.log.StaticLog;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelPromise;
+import io.netty.channel.FileRegion;
+import io.netty.handler.codec.http.DefaultHttpResponse;
+import io.netty.handler.codec.http.HttpContentCompressor;
+
+/**
+ * 解决大文件传输与Gzip压缩冲突问题
+ * @author Looly
+ *
+ */
+public class HttpChunkContentCompressor extends HttpContentCompressor {
+	@Override
+	public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
+		StaticLog.debug("Write object [{}]", msg);
+		
+		if (msg instanceof FileRegion || msg instanceof DefaultHttpResponse) {
+			//文件传输不经过Gzip压缩
+			ctx.write(msg, promise);
+		}else{
+			super.write(ctx, msg, promise);
+		}
+	}
+}
@@ -1,7 +1,6 @@
 package com.xiaoleilu.loServer.handler;

 import io.netty.util.internal.StringUtil;
-import com.xiaoleilu.hutool.util.FileUtil;
 import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelFutureListener;
@@ -8,7 +8,6 @@

 package com.xiaoleilu.loServer.handler;

-import com.xiaoleilu.hutool.lang.Singleton;
 import com.xiaoleilu.loServer.ServerSetting;
 import com.xiaoleilu.loServer.action.Action;
 import com.xiaoleilu.loServer.action.FileAction;
@@ -10,15 +10,12 @@ import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;

-import com.xiaoleilu.hutool.http.HttpUtil;
-import com.xiaoleilu.hutool.lang.Conver;
-import com.xiaoleilu.hutool.log.Log;
-import com.xiaoleilu.hutool.log.StaticLog;
-import com.xiaoleilu.hutool.util.CharsetUtil;
-import com.xiaoleilu.hutool.util.DateUtil;
-import com.xiaoleilu.hutool.util.StrUtil;
-import com.xiaoleilu.hutool.util.URLUtil;
-
+import cn.hutool.core.convert.Convert;
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.net.NetUtil;
+import cn.hutool.core.util.CharsetUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.core.util.URLUtil;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.http.FullHttpRequest;
 import io.netty.handler.codec.http.HttpHeaderNames;
@@ -261,7 +258,7 @@ public class Request {
 	 * @return 获得Integer类型请求参数
 	 */
 	public Integer getIntParam(String name, Integer defaultValue) {
-		return Conver.toInt(getParam(name), defaultValue);
+		return Convert.toInt(getParam(name), defaultValue);
 	}

 	/**
@@ -270,7 +267,7 @@ public class Request {
 	 * @return 获得long类型请求参数
 	 */
 	public Long getLongParam(String name, Long defaultValue) {
-		return Conver.toLong(getParam(name), defaultValue);
+		return Convert.toLong(getParam(name), defaultValue);
 	}

 	/**
@@ -279,7 +276,7 @@ public class Request {
 	 * @return 获得Double类型请求参数
 	 */
 	public Double getDoubleParam(String name, Double defaultValue) {
-		return Conver.toDouble(getParam(name), defaultValue);
+		return Convert.toDouble(getParam(name), defaultValue);
 	}

 	/**
@@ -288,7 +285,7 @@ public class Request {
 	 * @return 获得Float类型请求参数
 	 */
 	public Float getFloatParam(String name, Float defaultValue) {
-		return Conver.toFloat(getParam(name), defaultValue);
+		return Convert.toFloat(getParam(name), defaultValue);
 	}

 	/**
@@ -297,7 +294,7 @@ public class Request {
 	 * @return 获得Boolean类型请求参数
 	 */
 	public Boolean getBoolParam(String name, Boolean defaultValue) {
-		return Conver.toBool(getParam(name), defaultValue);
+		return Convert.toBool(getParam(name), defaultValue);
 	}

 	/**
@@ -477,7 +474,7 @@ public class Request {
 	protected void putIp(ChannelHandlerContext ctx) {
 		String ip = getHeader("X-Forwarded-For");
 		if (StrUtil.isNotBlank(ip)) {
-			ip = HttpUtil.getMultistageReverseProxyIp(ip);
+			ip = NetUtil.getMultistageReverseProxyIp(ip);
 		} else {
 			final InetSocketAddress insocket = (InetSocketAddress) ctx.channel().remoteAddress();
 			ip = insocket.getAddress().getHostAddress();
@@ -13,12 +13,9 @@ import java.util.Map.Entry;
 import java.util.Set;
 import java.util.TimeZone;

-import com.xiaoleilu.hutool.http.HttpUtil;
-import com.xiaoleilu.hutool.log.Log;
-import com.xiaoleilu.hutool.log.StaticLog;
-import com.xiaoleilu.hutool.util.CharsetUtil;
-import com.xiaoleilu.hutool.util.DateUtil;
-import com.xiaoleilu.hutool.util.StrUtil;
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.util.CharsetUtil;
+import cn.hutool.core.util.StrUtil;
 import com.xiaoleilu.loServer.ServerSetting;
 import com.xiaoleilu.loServer.listener.FileProgressiveFutureListener;

@@ -44,6 +41,8 @@ import io.netty.handler.codec.http.cookie.ServerCookieEncoder;
 import org.apache.tika.Tika;
 import org.slf4j.LoggerFactory;

+import static cn.hutool.core.date.DatePattern.HTTP_DATETIME_PATTERN;
+
 /**
 * 响应对象
 * 
@@ -332,7 +331,7 @@ public class Response {
 	 * @param httpCacheSeconds 缓存时间，单位秒
 	 */
 	public void setDateAndCache(long lastModify, int httpCacheSeconds) {
-		SimpleDateFormat formatter = new SimpleDateFormat(DateUtil.HTTP_DATETIME_PATTERN, Locale.US);
+		SimpleDateFormat formatter = new SimpleDateFormat(HTTP_DATETIME_PATTERN, Locale.US);
 		formatter.setTimeZone(TimeZone.getTimeZone("GMT"));

 		// Date header
@@ -2,10 +2,7 @@ package com.xiaoleilu.loServer.listener;

 import java.io.RandomAccessFile;

-import com.xiaoleilu.hutool.io.IoUtil;
-import com.xiaoleilu.hutool.log.Log;
-import com.xiaoleilu.hutool.log.StaticLog;
-
+import cn.hutool.core.io.IoUtil;
 import io.netty.channel.ChannelProgressiveFuture;
 import io.netty.channel.ChannelProgressiveFutureListener;
 import org.slf4j.LoggerFactory;
@@ -82,6 +82,15 @@ public final class BrokerConstants {
    public static final String QINIU_BUCKET_PORTRAIT_DOMAIN = "qiniu.bucket_portrait_domain";
    public static final String QINIU_BUCKET_FAVORITE_NAME= "qiniu.bucket_favorite_name";
    public static final String QINIU_BUCKET_FAVORITE_DOMAIN = "qiniu.bucket_favorite_domain";
+    public static final String QINIU_BUCKET_CUSTOM1_NAME= "qiniu.bucket_custom1_name";
+    public static final String QINIU_BUCKET_CUSTOM1_DOMAIN = "qiniu.bucket_custom1_domain";
+    public static final String QINIU_BUCKET_CUSTOM2_NAME= "qiniu.bucket_custom2_name";
+    public static final String QINIU_BUCKET_CUSTOM2_DOMAIN = "qiniu.bucket_custom2_domain";
+    public static final String QINIU_BUCKET_CUSTOM3_NAME= "qiniu.bucket_custom3_name";
+    public static final String QINIU_BUCKET_CUSTOM3_DOMAIN = "qiniu.bucket_custom3_domain";
+    public static final String QINIU_BUCKET_PAN_NAME= "qiniu.bucket_pan_name";
+    public static final String QINIU_BUCKET_PAN_DOMAIN = "qiniu.bucket_pan_domain";
+

    public static final String FILE_STORAGE_ROOT = "local.media.storage.root";
    public static final String FILE_STORAGE_REMOTE_SERVER_URL = "local.media.storage.remote_server_url";
@@ -90,6 +99,7 @@ public final class BrokerConstants {

    public static final String PUSH_ANDROID_SERVER_ADDRESS = "push.android.server.address";
    public static final String PUSH_IOS_SERVER_ADDRESS = "push.ios.server.address";
+    public static final String PUSH_HARMONY_SERVER_ADDRESS = "push.harmony.server.address";

    public static final String MONITOR_Exception_Event_Address = "monitor.exception_event_address";

@@ -115,13 +125,15 @@ public final class BrokerConstants {
    public static final String CONNECT_CLIENT_SIGNATURE_LIST = "connect.client_signature_list";
    public static final String CONNECT_REJECT_EMPTY_SIGNATURE = "connect.reject_empty_signature";

+    public static final String ID_USE_UUID = "id.use_uuid";
+
    public static final String EMBED_DB_PROPERTY_NAME = "embed.db";
    public static final String DB_AUTO_CLEAN_HISTORY_MESSAGES = "db.auto_clean_history_messages";
    public static final String H2DB_PATH = "h2db.path";


    public static final String SENSITIVE_Filter_Type = "sensitive.filter.type";
-
+    public static final String SENSITIVE_Only_Message = "sensitive.only_message";
    public static final String SENSITIVE_Remote_Server_URL = "sensitive.remote_server_url";
    public static final String SENSITIVE_Remote_Message_Type = "sensitive.remote_sensitive_message_type";
    public static final String SENSITIVE_Remote_Fail_When_Matched = "sensitive.remote_fail_when_matched";
@@ -135,6 +147,9 @@ public final class BrokerConstants {

    public static final String SERVER_MULTI_ENDPOINT = "server.multi_endpoint";
    public static final String SERVER_MULTI_PC_ENDPOINT = "server.multi_pc_endpoint";
+    public static final String SERVER_MULTI_PAD_ENDPOINT = "server.multi_pad_endpoint";
+    public static final String SERVER_MULTI_WEARABLE_ENDPOINT = "server.multi_wearable_endpoint";
+    public static final String SERVER_MULTI_TV_ENDPOINT = "server.multi_tv_endpoint";
    public static final String SERVER_MULTI_PLATFROM_NOTIFICATION = "server.multi_platform_notification";
    public static final String SERVER_MOBILE_DEFAULT_SILENT_WHEN_PC_ONLINE = "server.mobile_default_silent_when_pc_online";
    public static final String SERVER_CLIENT_SUPPORT_KICKOFF_EVENT = "server.client_support_kickoff_event";
@@ -148,19 +163,36 @@ public final class BrokerConstants {

    public static final String MESSAGE_Disable_Stranger_Chat = "message.disable_stranger_chat";
    public static final String MESSAGE_Allow_Stranger_Chat_List = "message.allow_stranger_chat_list";
+    public static final String MESSAGE_Allow_Stranger_Line = "message.allow_stranger_line";

    public static final String MESSAGE_Blacklist_Strategy = "message.blacklist.strategy";
+    public static final String MESSAGE_Blacklist_Allow_Send = "message.blacklist.allow_send_to_black";

    public static final String MESSAGE_NO_Forward_Admin_Message = "message.no_forward_admin_message";

    public static final String MESSAGE_Push_Expired_Days = "message.push_expired_days";
+    public static final String MESSAGE_Force_Push_Types = "message.force_push_types";

    public static final String MESSAGE_Forward_With_Client_Info = "message.forward_with_client_info";
+    public static final String MESSAGE_Forward_With_Sender_Info = "message.forward_with_sender_info";
+    public static final String MESSAGE_Forward_With_Target_Info = "message.forward_with_target_info";

    public static final String BROADCAST_Target_From_User_Table = "message.broadcast.target_from_user_table";

+    public static final String MESSAGES_ALLOW_SEND_TO_FORBIDDEN_USER = "message.allow_send_to_forbidden_user";
+
    public static final String ROBOT_Callback_With_Client_Info = "robot.callback_with_client_info";
+    public static final String ROBOT_Callback_With_Sender_Info = "robot.callback_with_sender_info";
+    public static final String ROBOT_Callback_With_Target_Info = "robot.callback_with_target_info";
+    public static final String ROBOT_Mention_External_Robot = "robot.mention_external_robot";
+    public static final String ROBOT_Get_User_Info_Mask = "robot.get_user_info_mask";
+    public static final String ROBOT_App_Allow_Any_Host = "robot.application_allow_any_host";
+
    public static final String CHANNEL_Callback_With_Client_Info = "channel.callback_with_client_info";
+    public static final String CHANNEL_Callback_With_Sender_Info = "channel.callback_with_sender_info";
+    public static final String CHANNEL_Callback_With_Target_Info = "channel.callback_with_target_info";
+    public static final String CHANNEL_New_Callback_Feature = "channel.new_callback_feature";
+    public static final String CHANNEL_App_Allow_Any_Host = "channel.application_allow_any_host";

    public static final String FRIEND_Disable_Search = "friend.disable_search";
    public static final String FRIEND_Disable_NickName_Search = "friend.disable_nick_name_search";
@@ -169,6 +201,9 @@ public final class BrokerConstants {
    public static final String FRIEND_Repeat_Request_Duration = "friend.repeat_request_duration";
    public static final String FRIEND_Reject_Request_Duration = "friend.reject_request_duration";
    public static final String FRIEND_Request_Expiration_Duration = "friend.request_expiration_duration";
+    public static final String FRIEND_Request_Rate_Limit = "friend.request_rate_limit";
+    public static final String FRIEND_Search_Mobile_Empty_Rate_Limit = "friend.search_mobile_empty_rate_limit";
+    public static final String FRIEND_Search_Rate_Limit = "friend.search_rate_limit";
    public static final String FRIEND_Request_Robot_Auto_Accept = "friend.robot_auto_accept";


@@ -186,9 +221,15 @@ public final class BrokerConstants {
    public static final String GROUP_Forbidden_Client_Operation = "group.forbidden_client_operation";

    public static final String GROUP_Disable_Stranger_Invite = "group.disable_stranger_invite";
+    public static final String GROUP_ADD_MEMBER_ALLOW_PART_SUCCESS = "group.add_member_allow_part_success";
+
+    public static final String GROUP_INFO_MARK_DELETION = "group.enable_mark_deletion";

    public static final String USER_HIDE_PROPERTIES = "user.hide_properties";
    public static final String USER_KEEP_DISPLAY_NAME_WHEN_DESTROY = "user.keep_display_name_when_destroy";
+    public static final String USER_KEEP_FULL_INFO_WHEN_DESTROY = "user.keep_full_info_when_destroy";
+    public static final String USER_KEEP_MOBILE_WHEN_DESTROY = "user.keep_mobile_when_destroy";
+    public static final String USER_KEEP_MESSAGES_WHEN_DESTROY = "user.keep_messages_when_destroy";

    public static final String SYNC_Data_Part_Size = "sync.data_part_size";

@@ -24,7 +24,8 @@ public class AddFriendHandler extends GroupHandler<WFCMessage.AddFriendRequest>
    public ErrorCode action(ByteBuf ackPayload, String clientID, String fromUser, ProtoConstants.RequestSourceType requestSourceType, WFCMessage.AddFriendRequest request, Qos1PublishHandler.IMCallback callback) {
            long[] head = new long[1];
            boolean isAdmin = requestSourceType == ProtoConstants.RequestSourceType.Request_From_Admin;
-            ErrorCode errorCode = m_messagesStore.saveAddFriendRequest(fromUser, request, head, isAdmin);
+            boolean isRobot = requestSourceType == ProtoConstants.RequestSourceType.Request_From_Robot;
+            ErrorCode errorCode = m_messagesStore.saveAddFriendRequest(fromUser, request, head, isAdmin, isRobot);
            if (errorCode == ERROR_CODE_SUCCESS) {
                WFCMessage.User user = m_messagesStore.getUserInfo(request.getTargetUid());
                if (user != null && user.getType() == ProtoConstants.UserType.UserType_Normal) {
@@ -16,6 +16,10 @@ import io.netty.buffer.ByteBuf;
 import cn.wildfirechat.common.ErrorCode;
 import win.liyufan.im.IMTopic;

+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
 import static cn.wildfirechat.common.ErrorCode.ERROR_CODE_SUCCESS;

@Handler(value = IMTopic.AddGroupMemberTopic)
@@ -38,16 +42,34 @@ public class AddGroupMember extends GroupHandler<WFCMessage.AddGroupMemberReques
            }
        }

-        ErrorCode errorCode = m_messagesStore.addGroupMembers(fromUser, isAdmin, request.getGroupId(), request.getAddedMemberList(), request.getExtra());
+        Map<String, Integer> failedMembers = new HashMap<>();
+        if(requestSourceType == ProtoConstants.RequestSourceType.Request_From_User) {
+            ErrorCode errorCode = m_messagesStore.canAddGroupMembers(fromUser, request.getAddedMemberList(), failedMembers);
+            if (errorCode != ErrorCode.ERROR_CODE_SUCCESS) {
+                return errorCode;
+            }
+        }
+
+        ErrorCode errorCode = m_messagesStore.addGroupMembers(fromUser, isAdmin, request.getGroupId(), request.getAddedMemberList(), request.getExtra(), failedMembers);
        if (errorCode == ERROR_CODE_SUCCESS) {
            if (request.hasNotifyContent() && request.getNotifyContent().getType() > 0) {
                sendGroupNotification(fromUser, request.getGroupId(), request.getToLineList(), request.getNotifyContent());
            } else {
-                WFCMessage.MessageContent content = new GroupNotificationBinaryContent(request.getGroupId(), fromUser, null, getMemberIdList(request.getAddedMemberList())).getAddGroupNotifyContent();
+                List<String> added = getMemberIdList(request.getAddedMemberList());
+                added.removeAll(failedMembers.keySet());
+                WFCMessage.MessageContent content = new GroupNotificationBinaryContent(request.getGroupId(), fromUser, null, added).setExtra(request.getExtra()).getAddGroupNotifyContent();
                sendGroupNotification(fromUser, request.getGroupId(), request.getToLineList(), content);
            }
        }

+        if (errorCode == ERROR_CODE_SUCCESS && !failedMembers.isEmpty()) {
+            WFCMessage.MessageContent content = new GroupNotificationBinaryContent(request.getGroupId(), fromUser, null, "").setMi(failedMembers).getGroupNotifyContent(ProtoConstants.MESSAGE_CONTENT_TYPE_REJECT_JOIN_GROUP);
+            sendGroupNotification(fromUser, request.getGroupId(), request.getToLineList(), content);
+        }
+
+        if(errorCode == ERROR_CODE_SUCCESS && !failedMembers.isEmpty()) {
+            return ErrorCode.ERROR_CODE_PARTLY_SUCCESS;
+        }
        return errorCode;
    }
 }
@@ -16,6 +16,7 @@ import io.netty.buffer.ByteBuf;
 import cn.wildfirechat.common.ErrorCode;
 import win.liyufan.im.IMTopic;

+import static cn.wildfirechat.proto.ProtoConstants.RequestSourceType.Request_From_Admin;
 import static win.liyufan.im.IMTopic.PutUserSettingTopic;
 import static win.liyufan.im.UserSettingScope.kUserSettingMyChannels;

@@ -42,7 +43,13 @@ public class CreateChannelHandler extends GroupHandler<WFCMessage.ChannelInfo> {
        if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
            WFCMessage.ModifyUserSettingReq modifyUserSettingReq = WFCMessage.ModifyUserSettingReq.newBuilder().setScope(kUserSettingMyChannels).setKey(request.getTargetId()).setValue("1").build();
            mServer.onApiMessage(fromUser, null, modifyUserSettingReq.toByteArray(), 0, fromUser, PutUserSettingTopic, requestSourceType);
-            byte[] data = request.getTargetId().getBytes();
+            byte[] data;
+            if (requestSourceType == Request_From_Admin) {
+                //When server api create channel, need return channelId and secret together.
+                data = (request.getTargetId() + "|" + request.getSecret()).getBytes();
+            } else {
+                data = request.getTargetId().getBytes();
+            }
            ackPayload.ensureWritable(data.length).writeBytes(data);
            return ErrorCode.ERROR_CODE_SUCCESS;
        } else {
@@ -17,6 +17,10 @@ import io.netty.buffer.ByteBuf;
 import cn.wildfirechat.common.ErrorCode;
 import win.liyufan.im.IMTopic;

+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
@Handler(value = IMTopic.CreateGroupTopic)
 public class CreateGroupHandler extends GroupHandler<WFCMessage.CreateGroupRequest> {
    @Override
@@ -27,7 +31,7 @@ public class CreateGroupHandler extends GroupHandler<WFCMessage.CreateGroupReque

        if (!StringUtil.isNullOrEmpty(request.getGroup().getGroupInfo().getTargetId())) {
            WFCMessage.GroupInfo existGroupInfo = m_messagesStore.getGroupInfo(request.getGroup().getGroupInfo().getTargetId());
-            if (existGroupInfo != null) {
+            if (existGroupInfo != null && existGroupInfo.getDeleted() == 0) {
                return ErrorCode.ERROR_CODE_GROUP_ALREADY_EXIST;
            }
        }
@@ -51,24 +55,54 @@ public class CreateGroupHandler extends GroupHandler<WFCMessage.CreateGroupReque
            }
        }

+        Map<String, Integer> failedMembers = new HashMap<>();
        if(requestSourceType == ProtoConstants.RequestSourceType.Request_From_User) {
-            ErrorCode errorCode = m_messagesStore.canAddGroupMembers(fromUser, request.getGroup().getMembersList());
+            ErrorCode errorCode = m_messagesStore.canAddGroupMembers(fromUser, request.getGroup().getMembersList(), failedMembers);
            if (errorCode != ErrorCode.ERROR_CODE_SUCCESS) {
                return errorCode;
            }
        }

-        WFCMessage.GroupInfo groupInfo = m_messagesStore.createGroup(fromUser, request.getGroup().getGroupInfo(), request.getGroup().getMembersList(), request.getMemberExtra(), isAdmin);
-        if (groupInfo != null) {
+        if (request.getGroup().getGroupInfo().getTargetId().length() > 64
+            || request.getGroup().getGroupInfo().getName().length() > 64
+            || request.getGroup().getGroupInfo().getPortrait().length() > 1024) {
+            return ErrorCode.INVALID_PARAMETER;
+        }
+
+        if(!isAdmin && !StringUtil.isNullOrEmpty(request.getGroup().getGroupInfo().getName())) {
+            if(!m_messagesStore.isSensitiveOnlyMessage()) {
+                Set<String> matched = m_messagesStore.handleSensitiveWord(request.getGroup().getGroupInfo().getName());
+                if (matched != null && !matched.isEmpty()) {
+                    return ErrorCode.ERROR_CODE_SENSITIVE_MATCHED;
+                }
+            }
+
+            if(!m_messagesStore.isAllowName(request.getGroup().getGroupInfo().getName())) {
+                return ErrorCode.ERROR_CODE_NOT_RIGHT;
+            }
+        }
+
+        WFCMessage.GroupInfo groupInfo = m_messagesStore.createGroup(fromUser, request.getGroup().getGroupInfo(), request.getGroup().getMembersList(), request.getMemberExtra(), isAdmin, failedMembers);
+        if (groupInfo != null && groupInfo.getDeleted() == 0) {
            if(request.hasNotifyContent() && request.getNotifyContent().getType() > 0) {
                sendGroupNotification(fromUser, groupInfo.getTargetId(), request.getToLineList(), request.getNotifyContent());
            } else {
-                WFCMessage.MessageContent content = new GroupNotificationBinaryContent(groupInfo.getTargetId(), fromUser, groupInfo.getName(), "").getCreateGroupNotifyContent();
+                WFCMessage.MessageContent content = new GroupNotificationBinaryContent(groupInfo.getTargetId(), fromUser, groupInfo.getName(), "").setExtra(request.getMemberExtra()).getCreateGroupNotifyContent();
+                sendGroupNotification(fromUser, groupInfo.getTargetId(), request.getToLineList(), content);
+            }
+
+            if(!failedMembers.isEmpty()) {
+                WFCMessage.MessageContent content = new GroupNotificationBinaryContent(groupInfo.getTargetId(), fromUser, null, "").setMi(failedMembers).getGroupNotifyContent(ProtoConstants.MESSAGE_CONTENT_TYPE_REJECT_JOIN_GROUP);
                sendGroupNotification(fromUser, groupInfo.getTargetId(), request.getToLineList(), content);
            }
        }
+
        byte[] data = groupInfo.getTargetId().getBytes();
        ackPayload.ensureWritable(data.length).writeBytes(data);
-        return ErrorCode.ERROR_CODE_SUCCESS;
+        if(failedMembers.isEmpty()) {
+            return ErrorCode.ERROR_CODE_SUCCESS;
+        } else {
+            return ErrorCode.ERROR_CODE_PARTLY_SUCCESS;
+        }
    }
 }
@@ -18,21 +18,32 @@ import io.moquette.server.config.MediaServerConfig;
 import io.moquette.spi.impl.Qos1PublishHandler;
 import io.netty.buffer.ByteBuf;

+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+
 import static io.moquette.server.config.MediaServerConfig.FILE_STROAGE_REMOTE_SERVER_URL;

@Handler("GMUT")
 public class GetMediaUploadTokenHandler extends IMHandler<WFCMessage.GetUploadTokenRequest> {
    @Override
    public ErrorCode action(ByteBuf ackPayload, String clientID, String fromUser, ProtoConstants.RequestSourceType requestSourceType, WFCMessage.GetUploadTokenRequest request, Qos1PublishHandler.IMCallback callback) {
+        String fileKey = request.getMediaPath();
+        if(fileKey.contains("/")) {
+            fileKey = fileKey.substring(fileKey.lastIndexOf("/")+1);
+        }
+
+        String encodedUserId = Base64.getEncoder().encodeToString(fromUser.getBytes(StandardCharsets.UTF_8)).replace("+", "-2B").replace("/", "-2F").replace("=", "-3D");
+        if(!fileKey.startsWith(fromUser) && !fileKey.startsWith(encodedUserId)) {
+            LOG.error("GetMediaUploadTokenHandler error: {}, {}", fromUser, request.getMediaPath());
+            return ErrorCode.ERROR_CODE_NOT_RIGHT;
+        }
+
        int type = request.getMediaType();
-
        String token;
-
        WFCMessage.GetUploadTokenResult.Builder resultBuilder = WFCMessage.GetUploadTokenResult.newBuilder();
        if (MediaServerConfig.USER_QINIU) {
            Auth auth = Auth.create(MediaServerConfig.QINIU_ACCESS_KEY, MediaServerConfig.QINIU_SECRET_KEY);

-
            String bucketName;
            String bucketDomain;
            switch (type) {
@@ -72,18 +83,34 @@ public class GetMediaUploadTokenHandler extends IMHandler<WFCMessage.GetUploadTo
                    bucketName = MediaServerConfig.QINIU_BUCKET_MOMENTS_NAME;
                    bucketDomain = MediaServerConfig.QINIU_BUCKET_MOMENTS_DOMAIN;
                    break;
+                case 9:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_CUSTOM1_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_CUSTOM1_DOMAIN;
+                    break;
+                case 10:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_CUSTOM2_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_CUSTOM2_DOMAIN;
+                    break;
+                case 11:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_CUSTOM3_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_CUSTOM3_DOMAIN;
+                    break;
+                case 12:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_PAN_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_PAN_DOMAIN;
+                    break;
                default:
                    bucketName = MediaServerConfig.QINIU_BUCKET_GENERAL_NAME;
                    bucketDomain = MediaServerConfig.QINIU_BUCKET_GENERAL_DOMAIN;
                    break;
            }

-            token = auth.uploadToken(bucketName);
+            token = auth.uploadToken(bucketName, request.getMediaPath());
            resultBuilder.setDomain(bucketDomain)
                .setServer(MediaServerConfig.QINIU_SERVER_URL);
            resultBuilder.setPort(80);
        } else {
-            token = UploadFileAction.getToken(type);
+            token = UploadFileAction.getToken(type, request.getMediaPath());
            if(StringUtil.isNullOrEmpty(MediaServerConfig.FILE_STROAGE_REMOTE_SERVER_URL)) {
                resultBuilder.setDomain("http://" + MediaServerConfig.SERVER_IP + ":" + MediaServerConfig.HTTP_SERVER_PORT);
            } else {
@@ -77,6 +77,22 @@ public class GetQiniuUploadTokenHandler extends IMHandler<Byte> {
                     bucketName = MediaServerConfig.QINIU_BUCKET_MOMENTS_NAME;
                     bucketDomain = MediaServerConfig.QINIU_BUCKET_MOMENTS_DOMAIN;
                     break;
+                case 9:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_CUSTOM1_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_CUSTOM1_DOMAIN;
+                    break;
+                case 10:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_CUSTOM2_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_CUSTOM2_DOMAIN;
+                    break;
+                case 11:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_CUSTOM3_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_CUSTOM3_DOMAIN;
+                    break;
+                case 12:
+                    bucketName = MediaServerConfig.QINIU_BUCKET_PAN_NAME;
+                    bucketDomain = MediaServerConfig.QINIU_BUCKET_PAN_DOMAIN;
+                    break;
                default:
                    bucketName = MediaServerConfig.QINIU_BUCKET_GENERAL_NAME;
                    bucketDomain = MediaServerConfig.QINIU_BUCKET_GENERAL_DOMAIN;
@@ -88,7 +104,7 @@ public class GetQiniuUploadTokenHandler extends IMHandler<Byte> {
                .setServer(MediaServerConfig.QINIU_SERVER_URL);
            resultBuilder.setPort(80);
        } else {
-            token = UploadFileAction.getToken(type);
+            token = UploadFileAction.getToken(type, null);
            resultBuilder.setDomain("http://" + MediaServerConfig.SERVER_IP + ":" + MediaServerConfig.HTTP_SERVER_PORT)
                .setServer(MediaServerConfig.SERVER_IP);
            resultBuilder.setPort(MediaServerConfig.HTTP_SERVER_PORT);
@@ -10,13 +10,13 @@ package io.moquette.imhandler;

 import cn.wildfirechat.proto.ProtoConstants;
 import cn.wildfirechat.proto.WFCMessage;
-import com.xiaoleilu.hutool.system.UserInfo;
 import io.moquette.persistence.MemorySessionStore;
 import io.moquette.spi.impl.Qos1PublishHandler;
 import io.moquette.spi.impl.security.TokenAuthenticator;
 import io.netty.buffer.ByteBuf;
 import cn.wildfirechat.common.ErrorCode;
 import win.liyufan.im.IMTopic;
+import win.liyufan.im.UserSettingScope;

@Handler(IMTopic.GetTokenTopic)
 public class GetTokenHandler extends IMHandler<WFCMessage.GetTokenRequest> {
@@ -27,6 +27,11 @@ public class GetTokenHandler extends IMHandler<WFCMessage.GetTokenRequest> {
        if(userInfo != null && userInfo.getType() == 1) {
            return ErrorCode.ERROR_CODE_ROBOT_NO_TOKEN;
        }
+        if(session.isPcClient() || session.isPadClient() || session.isTVClient()) {
+            if(m_messagesStore.isLocked(session.getUsername(), session.getClientID())) {
+                m_messagesStore.updateUserSettings(session.getUsername(), WFCMessage.ModifyUserSettingReq.newBuilder().setScope(UserSettingScope.UserSettingScopeLockPC).setKey(session.getClientID()).setValue("0").build(), null);
+            }
+        }

        TokenAuthenticator authenticator = new TokenAuthenticator();
        String strToken = authenticator.generateToken(fromUser);
@@ -45,20 +45,20 @@ public class HandleFriendRequestHandler extends IMHandler<WFCMessage.HandleFrien
                        contentBuilder.setType(92);

                        builder = WFCMessage.Message.newBuilder();
-                        builder.setFromUser(request.getTargetUid());
-                        builder.setConversation(WFCMessage.Conversation.newBuilder().setTarget(fromUser).setLine(0).setType(ProtoConstants.ConversationType.ConversationType_Private).build());
+                        builder.setFromUser(fromUser);
+                        builder.setConversation(WFCMessage.Conversation.newBuilder().setTarget(request.getTargetUid()).setLine(0).setType(ProtoConstants.ConversationType.ConversationType_Private).build());
                        builder.setContent(contentBuilder);
                        builder.setServerTimestamp(++timestamp);

                        messageId = MessageShardingUtil.generateId();
                        builder.setMessageId(messageId);
-                        saveAndPublish(request.getTargetUid(), null, builder.build(), requestSourceType);
+                        saveAndPublish(fromUser, null, builder.build(), requestSourceType);
                        contentBuilder.setType(93);
                        builder.setContent(contentBuilder);
                        messageId = MessageShardingUtil.generateId();
                        builder.setMessageId(messageId);
                        builder.setServerTimestamp(++timestamp);
-                        saveAndPublish(request.getTargetUid(), null, builder.build(), requestSourceType);
+                        saveAndPublish(fromUser, null, builder.build(), requestSourceType);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
@@ -11,11 +11,14 @@ package io.moquette.imhandler;
 import cn.wildfirechat.proto.ProtoConstants;
 import cn.wildfirechat.proto.WFCMessage;
 import cn.wildfirechat.pojos.GroupNotificationBinaryContent;
+import com.hazelcast.util.StringUtil;
 import io.moquette.spi.impl.Qos1PublishHandler;
 import io.netty.buffer.ByteBuf;
 import cn.wildfirechat.common.ErrorCode;
 import win.liyufan.im.IMTopic;

+import java.util.Set;
+
 import static cn.wildfirechat.common.ErrorCode.ERROR_CODE_SUCCESS;

@Handler(IMTopic.ModifyGroupAliasTopic)
@@ -26,10 +29,24 @@ public class ModifyGroupAliasHandler extends GroupHandler<WFCMessage.ModifyGroup
        if(request.hasNotifyContent() && request.getNotifyContent().getType() > 0 && requestSourceType == ProtoConstants.RequestSourceType.Request_From_User && !m_messagesStore.isAllowClientCustomGroupNotification()) {
            return ErrorCode.ERROR_CODE_NOT_RIGHT;
        }
+
        if(request.hasNotifyContent() && request.getNotifyContent().getType() > 0 && requestSourceType == ProtoConstants.RequestSourceType.Request_From_Robot && !m_messagesStore.isAllowRobotCustomGroupNotification()) {
            return ErrorCode.ERROR_CODE_NOT_RIGHT;
        }

+        if (!isAdmin && !StringUtil.isNullOrEmpty(request.getAlias())) {
+            if(!m_messagesStore.isSensitiveOnlyMessage()) {
+                Set<String> matched = m_messagesStore.handleSensitiveWord(request.getAlias());
+                if (matched != null && !matched.isEmpty()) {
+                    return ErrorCode.ERROR_CODE_SENSITIVE_MATCHED;
+                }
+            }
+
+            if(!m_messagesStore.isAllowName(request.getAlias())) {
+                return ErrorCode.ERROR_CODE_NOT_RIGHT;
+            }
+        }
+
        ErrorCode errorCode = m_messagesStore.modifyGroupMemberAlias(fromUser, request.getGroupId(), request.getAlias(), null, isAdmin);
        if (errorCode == ERROR_CODE_SUCCESS) {
            if (request.hasNotifyContent()&& request.getNotifyContent().getType() > 0) {
@@ -12,10 +12,13 @@ import cn.wildfirechat.common.ErrorCode;
 import cn.wildfirechat.pojos.GroupNotificationBinaryContent;
 import cn.wildfirechat.proto.ProtoConstants;
 import cn.wildfirechat.proto.WFCMessage;
+import com.hazelcast.util.StringUtil;
 import io.moquette.spi.impl.Qos1PublishHandler;
 import io.netty.buffer.ByteBuf;
 import win.liyufan.im.IMTopic;

+import java.util.Set;
+
 import static cn.wildfirechat.common.ErrorCode.ERROR_CODE_SUCCESS;

@Handler(IMTopic.ModifyGroupMemberAliasTopic)
@@ -29,6 +32,18 @@ public class ModifyGroupMemberAliasHandler extends GroupHandler<WFCMessage.Modif
        if(request.hasNotifyContent() && request.getNotifyContent().getType() > 0 && requestSourceType == ProtoConstants.RequestSourceType.Request_From_Robot && !m_messagesStore.isAllowRobotCustomGroupNotification()) {
            return ErrorCode.ERROR_CODE_NOT_RIGHT;
        }
+        if (!isAdmin && !StringUtil.isNullOrEmpty(request.getAlias())) {
+            if(!m_messagesStore.isSensitiveOnlyMessage()) {
+                Set<String> matched = m_messagesStore.handleSensitiveWord(request.getAlias());
+                if (matched != null && !matched.isEmpty()) {
+                    return ErrorCode.ERROR_CODE_SENSITIVE_MATCHED;
+                }
+            }
+
+            if(!m_messagesStore.isAllowName(request.getAlias())) {
+                return ErrorCode.ERROR_CODE_NOT_RIGHT;
+            }
+        }

        ErrorCode errorCode = m_messagesStore.modifyGroupMemberAlias(fromUser, request.getGroupId(), request.getAlias(), request.getMemberId(), isAdmin);
        if (errorCode == ERROR_CODE_SUCCESS) {
@@ -43,13 +43,13 @@ public class QuitGroupHandler extends GroupHandler<WFCMessage.QuitGroupRequest>
            if (request.hasNotifyContent() && request.getNotifyContent().getType() > 0) {
                sendGroupNotification(fromUser, request.getGroupId(), request.getToLineList(), request.getNotifyContent());
            } else {
-                WFCMessage.MessageContent content = new GroupNotificationBinaryContent(request.getGroupId(), fromUser, null, "").getQuitGroupNotifyContent();
+                WFCMessage.MessageContent content = new GroupNotificationBinaryContent(request.getGroupId(), fromUser, request.getKeepMsg()>0?"1":"0", "").getQuitGroupNotifyContent();
                sendGroupNotification(fromUser, request.getGroupId(), request.getToLineList(), content);
            }

            if((m_messagesStore.getVisibleQuitKickoffNotification() & 0x01) > 0) {
                Set<String> toUsers = m_messagesStore.getGroupManagers(request.getGroupId(), true);
-                WFCMessage.MessageContent content = new GroupNotificationBinaryContent(request.getGroupId(), fromUser, null, "").getQuitVisibleGroupNotifyContent();
+                WFCMessage.MessageContent content = new GroupNotificationBinaryContent(request.getGroupId(), fromUser, request.getKeepMsg()>0?"1":"0", "").getQuitVisibleGroupNotifyContent();
                sendGroupNotification(fromUser, request.getGroupId(), request.getToLineList(), content, toUsers);
            }
        }
@@ -0,0 +1,348 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package io.moquette.imhandler;
+
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.MessagePayload;
+import cn.wildfirechat.proto.ProtoConstants;
+import cn.wildfirechat.proto.WFCMessage;
+import com.hazelcast.util.StringUtil;
+import io.moquette.BrokerConstants;
+import io.moquette.spi.impl.Qos1PublishHandler;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import win.liyufan.im.*;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+import static cn.wildfirechat.common.ErrorCode.ERROR_CODE_NOT_IN_GROUP;
+import static cn.wildfirechat.common.ErrorCode.ERROR_CODE_SUCCESS;
+
+@Handler(value = IMTopic.RobotReplyMessageTopic)
+public class ReplyMessageHandler extends IMHandler<WFCMessage.Message> {
+    private int mSensitiveType = 0;  //命中敏感词时，0 失败，1 吞掉， 2 敏感词替换成*。
+    private String mForwardUrl = null;
+    private String mSensitiveMessageForwardUrl = null;
+    private Set<Integer> mForwardMessageTypes = new HashSet<>();
+    private Set<Integer> mForwardExcludeMessageTypes = new HashSet<>();
+    private String mMentionForwardUrl = null;
+    private int mBlacklistStrategy = 0; //黑名单中时，0失败，1吞掉。
+    private boolean mBlacklistAllowSend2Black = true;
+    private boolean mNoForwardAdminMessage = false;
+    private boolean mAllowSend2ForbiddenUser = false;
+
+    private String mRemoteSensitiveServerUrl = null;
+    private Set<Integer> mRemoteSensitiveMessageTypes;
+    private boolean mWaitRemoteSensitiveServerResponse = false;
+
+    public ReplyMessageHandler() {
+        super();
+
+        mForwardUrl = mServer.getConfig().getProperty(BrokerConstants.MESSAGE_Forward_Url);
+        if (!StringUtil.isNullOrEmpty(mForwardUrl)) {
+            String forwardTypes = mServer.getConfig().getProperty(BrokerConstants.MESSAGE_Forward_Types);
+            parseTypes(mForwardMessageTypes, forwardTypes);
+            String excludeTypes = mServer.getConfig().getProperty(BrokerConstants.MESSAGE_Forward_Exclude_Types);
+            parseTypes(mForwardExcludeMessageTypes, excludeTypes);
+        }
+        mSensitiveMessageForwardUrl = mServer.getConfig().getProperty(BrokerConstants.MESSAGE_Sensitive_Forward_Url);
+        mMentionForwardUrl = mServer.getConfig().getProperty(BrokerConstants.MESSAGE_MentionMsg_Forward_Url);
+
+        try {
+            mSensitiveType = Integer.parseInt(mServer.getConfig().getProperty(BrokerConstants.SENSITIVE_Filter_Type));
+        } catch (Exception e) {
+            e.printStackTrace();
+            Utility.printExecption(LOG, e);
+        }
+
+        try {
+            mBlacklistStrategy = Integer.parseInt(mServer.getConfig().getProperty(BrokerConstants.MESSAGE_Blacklist_Strategy));
+        } catch (Exception e) {
+            e.printStackTrace();
+            Utility.printExecption(LOG, e);
+        }
+
+        try {
+            mBlacklistAllowSend2Black = Boolean.parseBoolean(mServer.getConfig().getProperty(BrokerConstants.MESSAGE_Blacklist_Allow_Send, "true"));
+        } catch (Exception e) {
+        }
+
+        try {
+            mRemoteSensitiveServerUrl = mServer.getConfig().getProperty(BrokerConstants.SENSITIVE_Remote_Server_URL);
+            if(!StringUtil.isNullOrEmpty(mRemoteSensitiveServerUrl)) {
+                mWaitRemoteSensitiveServerResponse = Boolean.parseBoolean(mServer.getConfig().getProperty(BrokerConstants.SENSITIVE_Remote_Fail_When_Matched, "false"));
+                String types = mServer.getConfig().getProperty(BrokerConstants.SENSITIVE_Remote_Message_Type, "");
+                mRemoteSensitiveMessageTypes = new HashSet<>();
+                if(!StringUtil.isNullOrEmpty(types)) {
+                    String[] ts = types.split(",");
+                    for (String t:ts) {
+                        mRemoteSensitiveMessageTypes.add(Integer.parseInt(t.trim()));
+                    }
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            Utility.printExecption(LOG, e);
+        }
+
+        try {
+            mNoForwardAdminMessage = Boolean.parseBoolean(mServer.getConfig().getProperty(BrokerConstants.MESSAGE_NO_Forward_Admin_Message, "false"));
+        } catch (Exception e) {
+            e.printStackTrace();
+            Utility.printExecption(LOG, e);
+        }
+
+        try {
+            mAllowSend2ForbiddenUser = Boolean.parseBoolean(mServer.getConfig().getProperty(BrokerConstants.MESSAGES_ALLOW_SEND_TO_FORBIDDEN_USER, "false"));
+        } catch (Exception e) {}
+    }
+
+    private void parseTypes(Collection<Integer> collection, String types) {
+        try {
+            if (!StringUtil.isNullOrEmpty(types)) {
+                String[] tss = types.split(",");
+                for (String ts:tss) {
+                    if(ts.contains("-")) {
+                        String[] ss = ts.split("-");
+                        if(ss.length == 2) {
+                            int begin = Integer.parseInt(ss[0]);
+                            int end = Integer.parseInt(ss[1]);
+                            for (int i = begin; i <= end ; i++) {
+                                collection.add(i);
+                            }
+                        }
+                    } else {
+                        collection.add(Integer.parseInt(ts.trim()));
+                    }
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public ErrorCode action(ByteBuf ackPayload, String clientID, String fromUser, ProtoConstants.RequestSourceType requestSourceType, WFCMessage.Message message, Qos1PublishHandler.IMCallback callback) {
+        if(requestSourceType != ProtoConstants.RequestSourceType.Request_From_Robot) {
+            return ErrorCode.ERROR_CODE_NOT_IMPLEMENT;
+        }
+
+        ErrorCode errorCode = ErrorCode.ERROR_CODE_SUCCESS;
+
+        if (message != null) {
+            if(message.getContent().getContent().length() +
+                message.getContent().getSearchableContent().length() +
+                message.getContent().getData().size() +
+                message.getContent().getExtra().length() +
+                message.getContent().getPushContent().length() +
+                message.getContent().getPushData().length() > 64 * 1024) {
+                return ErrorCode.ERROR_CODE_MESSAGE_TOO_LARGE;
+            }
+
+            boolean ignoreMsg = false;
+
+                // 不能在端上直接发送撤回和群通知
+                if (message.getContent().getType() == 80 || message.getContent().getType() == 81 || (message.getContent().getType() >= 100 && message.getContent().getType() < 200)) {
+                    return ErrorCode.INVALID_PARAMETER;
+                }
+
+                if(m_messagesStore.getClientForbiddenSendTypes().contains(message.getContent().getType())) {
+                    return ErrorCode.ERROR_CODE_NOT_RIGHT;
+                }
+
+                int userStatus = m_messagesStore.getUserStatus(fromUser);
+                if (userStatus == ProtoConstants.UserStatus.Muted || userStatus == ProtoConstants.UserStatus.Forbidden) {
+                    if(!m_messagesStore.getGlobalMuteExceptionTypes().contains(message.getContent().getType())) {
+                        return ErrorCode.ERROR_CODE_FORBIDDEN_SEND_MSG;
+                    }
+                }
+
+                if (message.getConversation().getType() == ProtoConstants.ConversationType.ConversationType_Private) {
+                    if(!m_messagesStore.getBlackListExceptionTypes().contains(message.getContent().getType())) {
+                        errorCode = m_messagesStore.isAllowUserMessage(message.getConversation().getTarget(), fromUser, message.getConversation().getLine());
+                        if (errorCode != ErrorCode.ERROR_CODE_SUCCESS) {
+                            if (errorCode == ErrorCode.ERROR_CODE_IN_BLACK_LIST && mBlacklistStrategy != ProtoConstants.BlacklistStrategy.Message_Reject) {
+                                ignoreMsg = true;
+                                errorCode = ErrorCode.ERROR_CODE_SUCCESS;
+                            } else {
+                                return errorCode;
+                            }
+                        }
+
+                        if(!mBlacklistAllowSend2Black) {
+                            errorCode = m_messagesStore.isBlacked(fromUser, message.getConversation().getTarget());
+                            if (errorCode != ErrorCode.ERROR_CODE_SUCCESS) {
+                                return errorCode;
+                            }
+                        }
+                    }
+
+                    if (!mAllowSend2ForbiddenUser) {
+                        userStatus = m_messagesStore.getUserStatus(message.getConversation().getTarget());
+                        if (userStatus == ProtoConstants.UserStatus.Forbidden) {
+                            return ErrorCode.ERROR_CODE_USER_FORBIDDEN;
+                        }
+                    }
+                }
+
+                if (message.getConversation().getType() == ProtoConstants.ConversationType.ConversationType_Group ) {
+                    if(!m_messagesStore.getGroupMuteExceptionTypes().contains(message.getContent().getType())) {
+                        errorCode = m_messagesStore.canSendMessageInGroup(fromUser, message.getConversation().getTarget());
+                        if(errorCode == ERROR_CODE_NOT_IN_GROUP) {
+                            errorCode = ERROR_CODE_SUCCESS;
+                        }
+                        if (errorCode != ErrorCode.ERROR_CODE_SUCCESS) {
+                            return errorCode;
+                        }
+                    }
+                } else if (message.getConversation().getType() == ProtoConstants.ConversationType.ConversationType_ChatRoom) {
+                    if(!m_messagesStore.getGroupMuteExceptionTypes().contains(message.getContent().getType())) {
+                        if (!m_messagesStore.checkUserClientInChatroom(fromUser, clientID, message.getConversation().getTarget())) {
+                            return ErrorCode.ERROR_CODE_NOT_IN_CHATROOM;
+                        }
+                    }
+                } else if (message.getConversation().getType() == ProtoConstants.ConversationType.ConversationType_Channel) {
+                    if(!m_messagesStore.getGroupMuteExceptionTypes().contains(message.getContent().getType())) {
+                        if (!m_messagesStore.canSendMessageInChannel(fromUser, message.getConversation().getTarget())) {
+                            return ErrorCode.ERROR_CODE_NOT_IN_CHANNEL;
+                        }
+                    }
+                }
+
+            if(message.getConversation().getType() == ProtoConstants.ConversationType.ConversationType_Private) {
+                long beforeMessageId = message.getMessageId();
+                WFCMessage.Message replyMsg = m_messagesStore.getMessage(beforeMessageId);
+                message = message.toBuilder().setConversation(message.getConversation().toBuilder().setTarget(replyMsg.getFromUser() + "|" + replyMsg.getConversation().getTarget())).build();
+            }
+
+            long timestamp = System.currentTimeMillis();
+            final long messageId;
+            try {
+                messageId = MessageShardingUtil.generateId();
+            } catch (Exception e) {
+                e.printStackTrace();
+                return ErrorCode.ERROR_CODE_SERVER_ERROR;
+            }
+            message = message.toBuilder().setFromUser(fromUser).setMessageId(messageId).setServerTimestamp(timestamp).build();
+
+
+            if (!StringUtil.isNullOrEmpty(mForwardUrl) && (mForwardMessageTypes.isEmpty() || mForwardMessageTypes.contains(message.getContent().getType()))  && !mForwardExcludeMessageTypes.contains(message.getContent().getType())) {
+                publisher.forwardMessage(message, mForwardUrl, clientID);
+            }
+
+            if(!StringUtil.isNullOrEmpty(mMentionForwardUrl) && message.hasContent() && message.getContent().getMentionedType() != 0) {
+                publisher.forwardMessage(message, mMentionForwardUrl, clientID);
+            }
+
+
+                if(StringUtil.isNullOrEmpty(mRemoteSensitiveServerUrl)) {
+                    Set<String> matched = m_messagesStore.handleSensitiveWord(message.getContent().getSearchableContent());
+                    if (matched != null && !matched.isEmpty()) {
+                        m_messagesStore.storeSensitiveMessage(message);
+                        if (!StringUtil.isNullOrEmpty(mSensitiveMessageForwardUrl)) {
+                            publisher.forwardMessage(message, mSensitiveMessageForwardUrl, clientID);
+                        }
+                        if (mSensitiveType == 0) {
+                            errorCode = ErrorCode.ERROR_CODE_SENSITIVE_MATCHED;
+                        } else if (mSensitiveType == 1) {
+                            ignoreMsg = true;
+                        } else if (mSensitiveType == 2) {
+                            String text = message.getContent().getSearchableContent();
+                            for (String word : matched) {
+                                text = text.replace(word, "***");
+                            }
+                            message = message.toBuilder().setContent(message.getContent().toBuilder().setSearchableContent(text).build()).build();
+                        }
+                    }
+                } else {
+                    if(mRemoteSensitiveMessageTypes.contains(message.getContent().getType())) {
+                        final WFCMessage.Message finalMsg = message;
+                        publisher.forwardMessageWithCallback(message, clientID, mRemoteSensitiveServerUrl, new HttpUtils.HttpCallback() {
+                            @Override
+                            public void onSuccess(String content) {
+                                if(StringUtil.isNullOrEmpty(content)) {
+                                    saveAndPublish(fromUser, clientID, finalMsg, requestSourceType);
+                                } else {
+                                    MessagePayload payload = GsonUtil.gson.fromJson(content, MessagePayload.class);
+                                    if (payload != null && payload.getType() > 0) {
+                                        WFCMessage.Message newMsg = finalMsg.toBuilder().setContent(payload.toProtoMessageContent()).build();
+                                        saveAndPublish(fromUser, clientID, newMsg, requestSourceType);
+                                    } else {
+                                        LOG.error("Response content {} from censor is invalid payload, ignore response and send original message", content);
+                                        saveAndPublish(fromUser, clientID, finalMsg, requestSourceType);
+                                    }
+                                }
+                                if(mWaitRemoteSensitiveServerResponse) {
+                                    ByteBuf ackPayload = Unpooled.buffer(21);
+                                    ErrorCode errorCode = ERROR_CODE_SUCCESS;
+                                    ackPayload.writeByte(errorCode.getCode());
+                                    ackPayload.writeLong(messageId);
+                                    ackPayload.writeLong(timestamp);
+                                    callback.onIMHandled(ErrorCode.ERROR_CODE_SUCCESS, ackPayload);
+                                }
+                            }
+
+                            @Override
+                            public void onFailure(int statusCode, String errorMessage) {
+                                ByteBuf ackPayload = null;
+                                ErrorCode errorCode = ERROR_CODE_SUCCESS;
+                                if(statusCode == 403) {
+                                    if(mWaitRemoteSensitiveServerResponse) {
+                                        errorCode = ErrorCode.ERROR_CODE_SENSITIVE_MATCHED;
+                                        ackPayload = Unpooled.buffer(1);
+                                        ackPayload.writeByte(errorCode.getCode());
+                                    }
+                                } else {
+                                    LOG.warn("Failed to censor message with status {}, errorMessage {}. Send the original message", statusCode, errorMessage);
+                                    saveAndPublish(fromUser, clientID, finalMsg, requestSourceType);
+
+                                    if(mWaitRemoteSensitiveServerResponse) {
+                                        errorCode = ERROR_CODE_SUCCESS;
+                                        ackPayload = Unpooled.buffer(21);
+                                        ackPayload.writeByte(errorCode.getCode());
+                                        ackPayload.writeLong(messageId);
+                                        ackPayload.writeLong(timestamp);
+                                    }
+                                }
+
+                                if(mWaitRemoteSensitiveServerResponse) {
+                                    callback.onIMHandled(errorCode, ackPayload);
+                                }
+                            }
+                        });
+
+                        if(mWaitRemoteSensitiveServerResponse) {
+                            ackPayload.clear();
+                            return ErrorCode.INVALID_ASYNC_HANDLING;
+                        } else {
+                            ackPayload = ackPayload.capacity(20);
+                            ackPayload.writeLong(messageId);
+                            ackPayload.writeLong(timestamp);
+                            return ErrorCode.ERROR_CODE_SUCCESS;
+                        }
+                    }
+                }
+
+            if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
+                if(!ignoreMsg) {
+                    saveAndPublish(fromUser, clientID, message, requestSourceType);
+                }
+                ackPayload = ackPayload.capacity(20);
+                ackPayload.writeLong(messageId);
+                ackPayload.writeLong(timestamp);
+            }
+        } else {
+            errorCode = ErrorCode.ERROR_CODE_INVALID_MESSAGE;
+        }
+        return errorCode;
+    }
+
+}
@@ -37,7 +37,9 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
    private Set<Integer> mForwardExcludeMessageTypes = new HashSet<>();
    private String mMentionForwardUrl = null;
    private int mBlacklistStrategy = 0; //黑名单中时，0失败，1吞掉。
+    private boolean mBlacklistAllowSend2Black = true;
    private boolean mNoForwardAdminMessage = false;
+    private boolean mAllowSend2ForbiddenUser = false;

    private String mRemoteSensitiveServerUrl = null;
    private Set<Integer> mRemoteSensitiveMessageTypes;
@@ -69,6 +71,12 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
            e.printStackTrace();
            Utility.printExecption(LOG, e);
        }
+
+        try {
+            mBlacklistAllowSend2Black = Boolean.parseBoolean(mServer.getConfig().getProperty(BrokerConstants.MESSAGE_Blacklist_Allow_Send, "true"));
+        } catch (Exception e) {
+        }
+
        try {
            mRemoteSensitiveServerUrl = mServer.getConfig().getProperty(BrokerConstants.SENSITIVE_Remote_Server_URL);
            if(!StringUtil.isNullOrEmpty(mRemoteSensitiveServerUrl)) {
@@ -94,6 +102,9 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
            Utility.printExecption(LOG, e);
        }

+        try {
+            mAllowSend2ForbiddenUser = Boolean.parseBoolean(mServer.getConfig().getProperty(BrokerConstants.MESSAGES_ALLOW_SEND_TO_FORBIDDEN_USER, "false"));
+        } catch (Exception e) {}
    }

    private void parseTypes(Collection<Integer> collection, String types) {
@@ -125,6 +136,15 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
        ErrorCode errorCode = ErrorCode.ERROR_CODE_SUCCESS;
        boolean isAdmin = requestSourceType == ProtoConstants.RequestSourceType.Request_From_Admin;
        if (message != null) {
+            if(message.getContent().getContent().length() +
+                message.getContent().getSearchableContent().length() +
+                message.getContent().getData().size() +
+                message.getContent().getExtra().length() +
+                message.getContent().getPushContent().length() +
+                message.getContent().getPushData().length() > 64 * 1024) {
+                return ErrorCode.ERROR_CODE_MESSAGE_TOO_LARGE;
+            }
+
            boolean ignoreMsg = false;
            if (!isAdmin) {  //admin do not check the right
                // 不能在端上直接发送撤回和群通知
@@ -145,7 +165,7 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {

                if (message.getConversation().getType() == ProtoConstants.ConversationType.ConversationType_Private) {
                    if(!m_messagesStore.getBlackListExceptionTypes().contains(message.getContent().getType())) {
-                        errorCode = m_messagesStore.isAllowUserMessage(message.getConversation().getTarget(), fromUser);
+                        errorCode = m_messagesStore.isAllowUserMessage(message.getConversation().getTarget(), fromUser, message.getConversation().getLine());
                        if (errorCode != ErrorCode.ERROR_CODE_SUCCESS) {
                            if (errorCode == ErrorCode.ERROR_CODE_IN_BLACK_LIST && mBlacklistStrategy != ProtoConstants.BlacklistStrategy.Message_Reject) {
                                ignoreMsg = true;
@@ -154,11 +174,20 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
                                return errorCode;
                            }
                        }
+
+                        if(!mBlacklistAllowSend2Black) {
+                            errorCode = m_messagesStore.isBlacked(fromUser, message.getConversation().getTarget());
+                            if (errorCode != ErrorCode.ERROR_CODE_SUCCESS) {
+                                return errorCode;
+                            }
+                        }
                    }

-                    userStatus = m_messagesStore.getUserStatus(message.getConversation().getTarget());
-                    if (userStatus == ProtoConstants.UserStatus.Forbidden) {
-                        return ErrorCode.ERROR_CODE_USER_FORBIDDEN;
+                    if (!mAllowSend2ForbiddenUser) {
+                        userStatus = m_messagesStore.getUserStatus(message.getConversation().getTarget());
+                        if (userStatus == ProtoConstants.UserStatus.Forbidden) {
+                            return ErrorCode.ERROR_CODE_USER_FORBIDDEN;
+                        }
                    }
                }

@@ -203,20 +232,13 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
            }
            message = message.toBuilder().setFromUser(fromUser).setMessageId(messageId).setServerTimestamp(timestamp).build();

-            OutputClient outputClient = null;
-            if(m_messagesStore.isForwardMessageWithClientInfo() && requestSourceType == ProtoConstants.RequestSourceType.Request_From_User && !StringUtil.isNullOrEmpty(clientID)) {
-                MemorySessionStore.Session session = m_sessionsStore.getSession(clientID);
-                if(session != null && session.getUsername().equals(fromUser)) {
-                    outputClient = new OutputClient(session.getPlatform(), clientID);
-                }
-            }

            if (!StringUtil.isNullOrEmpty(mForwardUrl) && (mForwardMessageTypes.isEmpty() || mForwardMessageTypes.contains(message.getContent().getType())) && !(isAdmin && mNoForwardAdminMessage) && !mForwardExcludeMessageTypes.contains(message.getContent().getType())) {
-                publisher.forwardMessage(message, mForwardUrl, outputClient);
+                publisher.forwardMessage(message, mForwardUrl, clientID);
            }

            if(!StringUtil.isNullOrEmpty(mMentionForwardUrl) && message.hasContent() && message.getContent().getMentionedType() != 0 && !(isAdmin && mNoForwardAdminMessage)) {
-                publisher.forwardMessage(message, mMentionForwardUrl, outputClient);
+                publisher.forwardMessage(message, mMentionForwardUrl, clientID);
            }

            if (!isAdmin) {
@@ -225,7 +247,7 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
                    if (matched != null && !matched.isEmpty()) {
                        m_messagesStore.storeSensitiveMessage(message);
                        if (!StringUtil.isNullOrEmpty(mSensitiveMessageForwardUrl)) {
-                            publisher.forwardMessage(message, mSensitiveMessageForwardUrl, outputClient);
+                            publisher.forwardMessage(message, mSensitiveMessageForwardUrl, clientID);
                        }
                        if (mSensitiveType == 0) {
                            errorCode = ErrorCode.ERROR_CODE_SENSITIVE_MATCHED;
@@ -242,7 +264,7 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
                } else {
                    if(mRemoteSensitiveMessageTypes.contains(message.getContent().getType())) {
                        final WFCMessage.Message finalMsg = message;
-                        publisher.forwardMessageWithCallback(message, mRemoteSensitiveServerUrl, new HttpUtils.HttpCallback() {
+                        publisher.forwardMessageWithCallback(message, clientID, mRemoteSensitiveServerUrl, new HttpUtils.HttpCallback() {
                            @Override
                            public void onSuccess(String content) {
                                if(StringUtil.isNullOrEmpty(content)) {
@@ -0,0 +1,31 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package io.moquette.imhandler;
+
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.proto.ProtoConstants;
+import cn.wildfirechat.proto.WFCMessage;
+import io.moquette.spi.impl.Qos1PublishHandler;
+import io.netty.buffer.ByteBuf;
+import win.liyufan.im.IMTopic;
+import static cn.wildfirechat.common.ErrorCode.ERROR_CODE_SUCCESS;
+
+@Handler(IMTopic.SetFriendExtraTopic)
+public class SetFriendExtraHandler extends IMHandler<WFCMessage.StringPair> {
+    @Override
+    public ErrorCode action(ByteBuf ackPayload, String clientID, String fromUser, ProtoConstants.RequestSourceType requestSourceType, WFCMessage.StringPair request, Qos1PublishHandler.IMCallback callback) {
+        long[] heads = new long[1];
+        ErrorCode errorCode = m_messagesStore.setFriendExtraRequest(fromUser, request.getKey(), request.getValue(), heads);
+        if (errorCode == ERROR_CODE_SUCCESS) {
+            publisher.publishNotification(IMTopic.NotifyFriendTopic, fromUser, heads[0], clientID);
+        }
+
+        return errorCode;
+    }
+}
@@ -15,13 +15,18 @@ import io.netty.buffer.ByteBuf;
 import cn.wildfirechat.common.ErrorCode;
 import win.liyufan.im.IMTopic;

+import java.util.ArrayList;
 import java.util.List;

@Handler(IMTopic.UserSearchTopic)
 public class UserSearchHandler extends IMHandler<WFCMessage.SearchUserRequest> {
    @Override
    public ErrorCode action(ByteBuf ackPayload, String clientID, String fromUser, ProtoConstants.RequestSourceType requestSourceType, WFCMessage.SearchUserRequest request, Qos1PublishHandler.IMCallback callback) {
-        List<WFCMessage.User> users = m_messagesStore.searchUser(request.getKeyword(), request.getFuzzy(), request.getPage());
+        List<WFCMessage.User> users = new ArrayList<>();
+        ErrorCode errorCode = m_messagesStore.searchUser(fromUser, request.getKeyword(), request.getFuzzy(), request.getType(), request.getPage(), users);
+        if(errorCode != ErrorCode.ERROR_CODE_SUCCESS) {
+            return errorCode;
+        }
        WFCMessage.SearchUserResult.Builder builder = WFCMessage.SearchUserResult.newBuilder();
        builder.addAllEntry(users);
        byte[] data = builder.build().toByteArray();
@@ -36,6 +36,9 @@ import java.util.function.Function;

 import static cn.wildfirechat.common.IMExceptionEvent.EventType.RDBS_Exception;
 import static cn.wildfirechat.proto.ProtoConstants.PersistFlag.Transparent;
+import static cn.wildfirechat.proto.ProtoConstants.UserSearchUserType.UserSearchUserType_ONLY_ROBOT;
+import static cn.wildfirechat.proto.ProtoConstants.UserSearchUserType.UserSearchUserType_ONLY_USER;
+import static io.moquette.BrokerConstants.GROUP_INFO_MARK_DELETION;
 import static io.moquette.server.Constants.MAX_MESSAGE_QUEUE;
 import static cn.wildfirechat.proto.ProtoConstants.SearchUserType.*;
 import static win.liyufan.im.UserSettingScope.kUserSettingPrivacySearchable;
@@ -45,6 +48,7 @@ public class DatabaseStore {
    private final ThreadPoolExecutorWrapper mScheduler;
    private boolean disableRemoteMessageSearch = false;
    private boolean encryptMessage = false;
+    private boolean keepGroupInfo = false;
    public void setDisableRemoteMessageSearch(boolean disableRemoteMessageSearch) {
        this.disableRemoteMessageSearch = disableRemoteMessageSearch;
    }
@@ -55,6 +59,11 @@ public class DatabaseStore {

    public DatabaseStore(ThreadPoolExecutorWrapper scheduler) {
        this.mScheduler = scheduler;
+        try {
+            keepGroupInfo = Boolean.parseBoolean(Server.getServer().getConfig().getProperty(GROUP_INFO_MARK_DELETION, "false"));
+        } catch (Exception e) {
+
+        }
    }

    TreeMap<Long, Long> reloadUserMessageMaps(String userId) {
@@ -162,7 +171,7 @@ public class DatabaseStore {
        return null;
    }

-    List<WFCMessage.User> searchUserByNameMobileUserId(String keyword, int searchType) {
+    List<WFCMessage.User> searchUserByNameMobileUserId(String keyword, int searchType, int userType) {
        ArrayList<WFCMessage.User> out = new ArrayList<>();
        Connection connection = null;
        PreparedStatement statement = null;
@@ -196,7 +205,15 @@ public class DatabaseStore {
                sql += " where (`_name` = ? or `_mobile` = ? or `_uid` = ?) ";
            }

-            sql += " and `_type` <> 2 and `_deleted` = 0"; //can search normal user(0) and robot(1) and admin(100), can not search things
+            if(userType == UserSearchUserType_ONLY_USER) {
+                sql += " and _type <> 2 "; //can not search device
+                sql += " and _type <> 1 ";
+            } else if(userType == UserSearchUserType_ONLY_ROBOT) {
+                sql += " and _type = 1 ";
+            } else {
+                sql += " and _type <> 2 "; //can not search device
+            }
+            sql += " and _deleted = 0 ";

            if(searchType == SearchUserType_Name || searchType == SearchUserType_Mobile || searchType == SearchUserType_UserId) {
                sql += " limit 1";
@@ -401,7 +418,7 @@ public class DatabaseStore {
        return out;
    }

-    List<WFCMessage.User> searchUserByDisplayName(String keyword, int page, List<WFCMessage.User> nameOrIdMatched) {
+    List<WFCMessage.User> searchUserByDisplayName(String keyword, int userType, int page, List<WFCMessage.User> nameOrIdMatched) {
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet rs = null;
@@ -412,7 +429,18 @@ public class DatabaseStore {
            connection = DBUtil.getConnection();
            String sql = "select u._uid, u._name, u._display_name, u._portrait, u._mobile, u._gender, u._email, u._address, u._company, u._social, u._extra, u._dt, u._type " +
                " from t_user u left join (select _uid, _value from t_user_setting where _scope = 27) s on u._uid = s._uid " +
-                " where u._display_name like ? ESCAPE '!' and u._type <> 2 and u._deleted = 0 ";
+                " where u._display_name like ? ESCAPE '!' ";
+
+            if(userType == UserSearchUserType_ONLY_USER) {
+                sql += " and u._type <> 2 ";
+                sql += " and u._type <> 1 ";
+            } else if(userType == UserSearchUserType_ONLY_ROBOT) {
+                sql += " and u._type = 1 ";
+            } else {
+                sql += " and u._type <> 2 ";
+            }
+            sql += " and u._deleted = 0 ";
+
            if(nameOrIdMatched.size() == 1) {
                sql += " and u._uid <> ? and u._name <> ?";
            } else if(nameOrIdMatched.size() == 2) {
@@ -516,15 +544,15 @@ public class DatabaseStore {
        return out;
    }

-    List<WFCMessage.User> searchUserFromDB(String keyword, int searchType, int page) {
-        List<WFCMessage.User> nameOrIdMatched = searchUserByNameMobileUserId(keyword, searchType);
+    List<WFCMessage.User> searchUserFromDB(String keyword, int searchType, int userType, int page) {
+        List<WFCMessage.User> nameOrIdMatched = searchUserByNameMobileUserId(keyword, searchType, userType);
        List<WFCMessage.User> out = new ArrayList<>();
        if(page == 0) {
            out.addAll(nameOrIdMatched);
        }

        if(searchType == SearchUserType_General || searchType == SearchUserType_Name_Mobile_DisplayName) {
-            List<WFCMessage.User> general = searchUserByDisplayName(keyword, page, nameOrIdMatched);
+            List<WFCMessage.User> general = searchUserByDisplayName(keyword, userType, page, nameOrIdMatched);
            general.removeAll(nameOrIdMatched);
            out.addAll(general);
        }
@@ -1129,7 +1157,16 @@ public class DatabaseStore {
                }

                if (!expired) {
-                    messages.add(message);
+                    boolean duplicated = false;
+                    for (WFCMessage.Message msg : messages) {
+                        if(message.getMessageId() == msg.getMessageId()) {
+                            duplicated = true;
+                            break;
+                        }
+                    }
+                    if(!duplicated) {
+                        messages.add(message);
+                    }
                }
            }

@@ -1425,7 +1462,8 @@ public class DatabaseStore {
                ", `_join_type`" +
                ", `_private_chat`" +
                ", `_searchable`" +
-                ", `_member_dt`) values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)" +
+                ", `_deleted`" +
+                ", `_member_dt`) values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)" +
                " ON DUPLICATE KEY UPDATE " +
                "`_name` = ?," +
                "`_portrait` = ?," +
@@ -1436,8 +1474,9 @@ public class DatabaseStore {
                "`_mute` = ?" +
                ", `_join_type` = ?" +
                ", `_private_chat` = ?" +
-                ", `_searchable` = ?, " +
-                "`_member_dt` = ?";
+                ", `_searchable` = ?" +
+                ", `_deleted` = ?" +
+                ", `_member_dt` = ?";


            statement = connection.prepareStatement(sql);
@@ -1455,6 +1494,7 @@ public class DatabaseStore {
            statement.setInt(index++, groupInfo.getJoinType());
            statement.setInt(index++, groupInfo.getPrivateChat());
            statement.setInt(index++, groupInfo.getSearchable());
+            statement.setInt(index++, groupInfo.getDeleted());
            statement.setLong(index++, groupInfo.getMemberUpdateDt() == 0 ? System.currentTimeMillis() : groupInfo.getUpdateDt());

            statement.setString(index++, groupInfo.getName());
@@ -1467,6 +1507,7 @@ public class DatabaseStore {
            statement.setInt(index++, groupInfo.getJoinType());
            statement.setInt(index++, groupInfo.getPrivateChat());
            statement.setInt(index++, groupInfo.getSearchable());
+            statement.setInt(index++, groupInfo.getDeleted());
            statement.setLong(index++, groupInfo.getMemberUpdateDt() == 0 ? System.currentTimeMillis() : groupInfo.getUpdateDt());
            int count = statement.executeUpdate();
            LOG.info("Update rows {}", count);
@@ -1791,6 +1832,31 @@ public class DatabaseStore {
        });
    }

+    void updateSessionIp(String uid, String cid, String ip) {
+        mScheduler.execute(()->{
+            Connection connection = null;
+            PreparedStatement statement = null;
+            try {
+                connection = DBUtil.getConnection();
+                String sql = "update t_user_session set _ip = ?  where `_uid` = ? and `_cid` = ?";
+                statement = connection.prepareStatement(sql);
+                int index = 1;
+                statement.setString(index++, ip);
+                statement.setString(index++, uid);
+                statement.setString(index++, cid);
+
+                int c = statement.executeUpdate();
+                LOG.info("Update rows {}", c);
+            } catch (SQLException e) {
+                // TODO Auto-generated catch block
+                e.printStackTrace();
+                Utility.printExecption(LOG, e, RDBS_Exception);
+            } finally {
+                DBUtil.closeDB(connection, statement);
+            }
+        });
+    }
+
    void clearMultiEndpoint(String uid, String clientId, int platform) {
        LOG.info("clearMultiEndpoint {}, {}", uid, clientId);
        Connection connection = null;
@@ -1798,10 +1864,16 @@ public class DatabaseStore {
        try {
            connection = DBUtil.getConnection();
            String sql;
-            if (platform == ProtoConstants.Platform.Platform_Windows || platform == ProtoConstants.Platform.Platform_OSX || platform == ProtoConstants.Platform.Platform_LINUX) {
+            if (platform == ProtoConstants.Platform.Platform_Windows || platform == ProtoConstants.Platform.Platform_OSX || platform == ProtoConstants.Platform.Platform_LINUX || platform == ProtoConstants.Platform.Platform_HarmonyPC) {
+                sql = "update t_user_session set `_deleted` = ?, `_token` = ?, `_voip_token` = ?, `_dt` = ?  where `_uid`=? and (`_platform` = ? or `_platform` = ? or `_platform` = ? or `_platform` = ?)  and `_cid` <> ? and `_deleted` = 0";
+            } else if(platform == ProtoConstants.Platform.Platform_iOS || platform == ProtoConstants.Platform.Platform_Android || platform == ProtoConstants.Platform.Platform_Harmony) {
                sql = "update t_user_session set `_deleted` = ?, `_token` = ?, `_voip_token` = ?, `_dt` = ?  where `_uid`=? and (`_platform` = ? or `_platform` = ? or `_platform` = ?)  and `_cid` <> ? and `_deleted` = 0";
-            } else if(platform == ProtoConstants.Platform.Platform_iOS || platform == ProtoConstants.Platform.Platform_Android) {
+            } else if(platform == ProtoConstants.Platform.Platform_iPad || platform == ProtoConstants.Platform.Platform_APad || platform == ProtoConstants.Platform.Platform_HarmonyPad) {
+                sql = "update t_user_session set `_deleted` = ?, `_token` = ?, `_voip_token` = ?, `_dt` = ?  where `_uid`=? and (`_platform` = ? or `_platform` = ? or `_platform` = ?)  and `_cid` <> ? and `_deleted` = 0";
+            } else if(platform == ProtoConstants.Platform.Platform_AndroidWearable || platform == ProtoConstants.Platform.Platform_HarmonyWearable) {
                sql = "update t_user_session set `_deleted` = ?, `_token` = ?, `_voip_token` = ?, `_dt` = ?  where `_uid`=? and (`_platform` = ? or `_platform` = ?)  and `_cid` <> ? and `_deleted` = 0";
+            } else if(platform == ProtoConstants.Platform.Platform_AndroidTV || platform == ProtoConstants.Platform.Platform_AppleTV || platform == ProtoConstants.Platform.Platform_HarmonyTV) {
+                sql = "update t_user_session set `_deleted` = ?, `_token` = ?, `_voip_token` = ?, `_dt` = ?  where `_uid`=? and (`_platform` = ? or `_platform` = ? or `_platform` = ?)  and `_cid` <> ? and `_deleted` = 0";
            } else {
                sql = "update t_user_session set `_deleted` = ?, `_token` = ?, `_voip_token` = ?, `_dt` = ?  where `_uid`=? and `_platform` = ? and `_cid` <> ? and `_deleted` = 0";
            }
@@ -1816,13 +1888,26 @@ public class DatabaseStore {

            statement.setString(index++, uid);

-            if (platform == ProtoConstants.Platform.Platform_Windows || platform == ProtoConstants.Platform.Platform_OSX || platform == ProtoConstants.Platform.Platform_LINUX) {
+            if (platform == ProtoConstants.Platform.Platform_Windows || platform == ProtoConstants.Platform.Platform_OSX || platform == ProtoConstants.Platform.Platform_LINUX || platform == ProtoConstants.Platform.Platform_HarmonyPC) {
                statement.setInt(index++, ProtoConstants.Platform.Platform_Windows);
                statement.setInt(index++, ProtoConstants.Platform.Platform_OSX);
                statement.setInt(index++, ProtoConstants.Platform.Platform_LINUX);
-            } else if(platform == ProtoConstants.Platform.Platform_iOS || platform == ProtoConstants.Platform.Platform_Android) {
+                statement.setInt(index++, ProtoConstants.Platform.Platform_HarmonyPC);
+            } else if(platform == ProtoConstants.Platform.Platform_iOS || platform == ProtoConstants.Platform.Platform_Android || platform == ProtoConstants.Platform.Platform_Harmony) {
                statement.setInt(index++, ProtoConstants.Platform.Platform_iOS);
                statement.setInt(index++, ProtoConstants.Platform.Platform_Android);
+                statement.setInt(index++, ProtoConstants.Platform.Platform_Harmony);
+            } else if(platform == ProtoConstants.Platform.Platform_iPad || platform == ProtoConstants.Platform.Platform_APad || platform == ProtoConstants.Platform.Platform_HarmonyPad) {
+                statement.setInt(index++, ProtoConstants.Platform.Platform_iPad);
+                statement.setInt(index++, ProtoConstants.Platform.Platform_APad);
+                statement.setInt(index++, ProtoConstants.Platform.Platform_HarmonyPad);
+            } else if(platform == ProtoConstants.Platform.Platform_AndroidWearable || platform == ProtoConstants.Platform.Platform_HarmonyWearable) {
+                statement.setInt(index++, ProtoConstants.Platform.Platform_AndroidWearable);
+                statement.setInt(index++, ProtoConstants.Platform.Platform_HarmonyWearable);
+            } else if(platform == ProtoConstants.Platform.Platform_AndroidTV || platform == ProtoConstants.Platform.Platform_AppleTV || platform == ProtoConstants.Platform.Platform_HarmonyTV) {
+                statement.setInt(index++, ProtoConstants.Platform.Platform_AndroidTV);
+                statement.setInt(index++, ProtoConstants.Platform.Platform_AppleTV);
+                statement.setInt(index++, ProtoConstants.Platform.Platform_HarmonyTV);
            } else {
                statement.setInt(index++, platform);
            }
@@ -2175,6 +2260,7 @@ public class DatabaseStore {
                ", `_join_type`" +
                ", `_private_chat`" +
                ", `_searchable`" +
+                ", _deleted" +
                " from t_group  where `_gid` = ?";

            statement = connection.prepareStatement(sql);
@@ -2231,6 +2317,9 @@ public class DatabaseStore {
                intValue = rs.getInt(index++);
                builder.setSearchable(intValue);

+                intValue = rs.getInt(index++);
+                builder.setDeleted(intValue);
+
                return builder.build();
            }
        } catch (SQLException e) {
@@ -2909,6 +2998,195 @@ public class DatabaseStore {
        return null;
    }

+    List<WFCMessage.User> getUserInfosByEmail(String email) {
+        Connection connection = null;
+        PreparedStatement statement = null;
+        ResultSet rs = null;
+        List<WFCMessage.User> outList = new ArrayList<>();
+        try {
+            connection = DBUtil.getConnection();
+            String sql = "select `_uid`, `_name`" +
+                ", `_display_name`" +
+                ", `_portrait`" +
+                ", `_mobile`" +
+                ", `_gender`" +
+                ", `_email`" +
+                ", `_address`" +
+                ", `_company`" +
+                ", `_social`" +
+                ", `_extra`" +
+                ", `_type`" +
+                ", `_deleted`" +
+                ", `_dt` from t_user where `_deleted` = 0 and `_email` = ?";
+            statement = connection.prepareStatement(sql);
+            statement.setString(1, email);
+
+            rs = statement.executeQuery();
+            while (rs.next()) {
+                WFCMessage.User.Builder builder = WFCMessage.User.newBuilder();
+                int index = 1;
+                String value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setUid(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setName(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setDisplayName(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setPortrait(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setMobile(value);
+
+                int gender = rs.getInt(index++);
+                builder.setGender(gender);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setEmail(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setAddress(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setCompany(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setSocial(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setExtra(value);
+
+                int type = rs.getInt(index++);
+                builder.setType(type);
+
+                int deleted = rs.getInt(index++);
+                builder.setDeleted(deleted);
+
+                long longValue = rs.getLong(index++);
+                if(longValue <= 0)
+                    longValue = 1;
+                builder.setUpdateDt(longValue);
+
+                outList.add(builder.build());
+            }
+        } catch (SQLException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+            Utility.printExecption(LOG, e, RDBS_Exception);
+        } finally {
+            DBUtil.closeDB(connection, statement, rs);
+        }
+        return outList;
+    }
+
+    List<WFCMessage.User> getUserInfosByMobile(String mobile, boolean includeDeleted) {
+        Connection connection = null;
+        PreparedStatement statement = null;
+        ResultSet rs = null;
+        List<WFCMessage.User> outList = new ArrayList<>();
+        try {
+            connection = DBUtil.getConnection();
+            String sql = "select `_uid`, `_name`" +
+                ", `_display_name`" +
+                ", `_portrait`" +
+                ", `_mobile`" +
+                ", `_gender`" +
+                ", `_email`" +
+                ", `_address`" +
+                ", `_company`" +
+                ", `_social`" +
+                ", `_extra`" +
+                ", `_type`" +
+                ", `_deleted`" +
+                ", `_dt` from t_user where `_mobile` = ?";
+            if(!includeDeleted) {
+                sql += " and `_deleted` = 0";
+            }
+            statement = connection.prepareStatement(sql);
+            statement.setString(1, mobile);
+
+            rs = statement.executeQuery();
+            while (rs.next()) {
+                WFCMessage.User.Builder builder = WFCMessage.User.newBuilder();
+                int index = 1;
+                String value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setUid(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setName(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setDisplayName(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setPortrait(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setMobile(value);
+
+                int gender = rs.getInt(index++);
+                builder.setGender(gender);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setEmail(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setAddress(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setCompany(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setSocial(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setExtra(value);
+
+                int type = rs.getInt(index++);
+                builder.setType(type);
+
+                int deleted = rs.getInt(index++);
+                builder.setDeleted(deleted);
+
+                long longValue = rs.getLong(index++);
+                if(longValue <= 0)
+                    longValue = 1;
+                builder.setUpdateDt(longValue);
+
+                outList.add(builder.build());
+            }
+        } catch (SQLException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+            Utility.printExecption(LOG, e, RDBS_Exception);
+        } finally {
+            DBUtil.closeDB(connection, statement, rs);
+        }
+        return outList;
+    }
+
    List<WFCMessage.User> getAllUsers(int count, int offset) {
        Connection connection = null;
        PreparedStatement statement = null;
@@ -3006,6 +3284,97 @@ public class DatabaseStore {
        return outList;
    }

+    List<WFCMessage.Robot> getAllRobots(int count, int offset) {
+        Connection connection = null;
+        PreparedStatement statement = null;
+        ResultSet rs = null;
+        List<WFCMessage.Robot> outList = new ArrayList<>();
+
+        try {
+            connection = DBUtil.getConnection();
+            String sql = "select  `_uid`, `_owner`" +
+                ", `_secret`" +
+                ", `_callback`" +
+                ", `_state`" +
+                ", `_extra`" +
+                ", `_dt` from t_robot limit ? offset ?";
+            statement = connection.prepareStatement(sql);
+
+            int index = 1;
+            statement.setInt(1, count);
+            statement.setInt(2, offset);
+
+            rs = statement.executeQuery();
+            while (rs.next()) {
+                WFCMessage.Robot.Builder builder = WFCMessage.Robot.newBuilder();
+                index = 1;
+                String value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setUid(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setOwner(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setSecret(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setCallback(value);
+
+
+                int state = rs.getInt(index++);
+                builder.setState(state);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setExtra(value);
+
+                long longValue = rs.getLong(index++);
+
+                outList.add(builder.build());
+            }
+        } catch (SQLException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+            Utility.printExecption(LOG, e, RDBS_Exception);
+        } finally {
+            DBUtil.closeDB(connection, statement, rs);
+        }
+
+        return outList;
+    }
+
+    List<String> getUserRobotIds(String userId) {
+        Connection connection = null;
+        PreparedStatement statement = null;
+        ResultSet rs = null;
+        List<String> outList = new ArrayList<>();
+        try {
+            connection = DBUtil.getConnection();
+            String sql = "select _uid from t_robot where _owner = ? and _state = 0";
+            statement = connection.prepareStatement(sql);
+
+            int index = 1;
+            statement.setString(1, userId);
+
+            rs = statement.executeQuery();
+            while (rs.next()) {
+                outList.add(rs.getString(1));
+            }
+        } catch (SQLException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+            Utility.printExecption(LOG, e, RDBS_Exception);
+        } finally {
+            DBUtil.closeDB(connection, statement, rs);
+        }
+        return outList;
+    }
+
+
    Set<String> getAllEnds(boolean fromUserTable) {
        Connection connection = null;
        PreparedStatement statement = null;
@@ -3309,8 +3678,12 @@ public class DatabaseStore {
        PreparedStatement statement = null;
        try {
            connection = DBUtil.getConnection();
-            String sql = "delete from t_group where _gid = ?";
-
+            String sql;
+            if(keepGroupInfo) {
+                sql = "update t_group set _deleted = 1, _dt = _dt+1, _member_count = 0, _member_dt = _member_dt+1 where _gid = ?";
+            } else {
+                sql = "delete from t_group where _gid = ?";
+            }

            statement = connection.prepareStatement(sql);
            int index = 1;
@@ -3544,7 +3917,6 @@ public class DatabaseStore {
        return null;
    }

-
    void persistChannelListener(final String groupId, final List<String> memberList) {
        mScheduler.execute(()->{
            Connection connection = null;
@@ -3642,7 +4014,11 @@ public class DatabaseStore {
                sql += " where `_name` = ?";
            }

-            sql += " and _status = 0";
+            sql += " and _status <> 64";
+            sql += " and _status <> 16";
+            sql += " and _status <> 17";
+            sql += " and _status <> 24";
+            sql += " and _status <> 25";

            sql += " limit 20";

@@ -3805,6 +4181,313 @@ public class DatabaseStore {
        }
    }

+    void batchInsertChannelListener(String channelId, List<String> listeners, boolean listen) throws SQLException {
+        LOG.info("updateChannelListener {}", channelId);
+        Connection connection = null;
+        PreparedStatement statement = null;
+        try {
+            connection = DBUtil.getConnection();
+            int size = 0;
+            String sql = listen
+                ? "insert into t_channel_listener (_cid, _mid, _dt) values(?, ?, ?)"
+                : "delete from t_channel_listener where _cid=? and _mid=?";
+            statement = connection.prepareStatement(sql);
+
+            for (String listener : listeners) {
+                int index = 1;
+                statement.setString(index++, channelId);
+                statement.setString(index++, listener);
+                if (listen) {
+                    statement.setLong(index++, System.currentTimeMillis());
+                }
+                statement.addBatch();
+                if(++size%100 == 0) {
+                    statement.executeBatch();
+                    statement.clearBatch();
+                }
+            }
+            if(size%100 != 0) {
+                statement.executeBatch();
+            }
+        } catch (SQLException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+            Utility.printExecption(LOG, e, RDBS_Exception);
+            throw e;
+        } finally {
+            DBUtil.closeDB(connection, statement);
+        }
+    }
+
+    public List<String> findMissingMids(String cid, List<String> midList, boolean contain) {
+        if (midList == null || midList.isEmpty()) {
+            return new ArrayList<>();
+        }
+
+        String tempTable = "temp_check_mids_" + System.currentTimeMillis();
+        Connection conn = null;
+        try {
+            conn = DBUtil.getConnection();
+
+            // Step 1: 创建临时表
+            try (Statement st = conn.createStatement()) {
+                st.execute("CREATE TEMPORARY TABLE " + tempTable +
+                    " (_mid VARCHAR(64) NOT NULL PRIMARY KEY)");
+            }
+
+            // Step 2: 批量插入
+            String insertSql = "INSERT IGNORE INTO " + tempTable + " (_mid) VALUES (?)";
+            try (PreparedStatement ps = conn.prepareStatement(insertSql)) {
+                int count = 0;
+                for (String mid : midList) {
+                    ps.setString(1, mid);
+                    ps.addBatch();
+                    if (++count % 1000 == 0) {
+                        ps.executeBatch();
+                        ps.clearBatch();
+                    }
+                }
+                if (count % 1000 != 0) {
+                    ps.executeBatch();
+                }
+            }
+
+            // Step 3: 查询
+            String querySql = "SELECT t._mid FROM " + tempTable + " t " +
+                "WHERE " + (contain ? "" : " NOT ") + " EXISTS (" +
+                "    SELECT 1 FROM t_channel_listener c " +
+                "    WHERE c._cid = ? AND c._mid = t._mid" +
+                ")";
+
+            List<String> result = new ArrayList<>();
+            try (PreparedStatement ps = conn.prepareStatement(querySql)) {
+                ps.setString(1, cid);
+                try (ResultSet rs = ps.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(rs.getString(1));
+                    }
+                }
+            }
+
+            return result;
+        } catch (SQLException e) {
+            throw new RuntimeException("查询缺失mid失败", e);
+        } finally {
+            // 显式清理临时表
+            if (conn != null) {
+                try (Statement st = conn.createStatement()) {
+                    st.execute("DROP TEMPORARY TABLE IF EXISTS " + tempTable);
+                } catch (SQLException ignored) {
+                    // 清理失败不影响主流程
+                } finally {
+                    try { conn.close(); } catch (SQLException ignored) {}
+                }
+            }
+        }
+    }
+
+    List<WFCMessage.ChannelInfo> getChannelInfoList(int count, int offset, boolean withDeleted) {
+        List<WFCMessage.ChannelInfo> out = new ArrayList<>();
+        Connection connection = null;
+        PreparedStatement statement = null;
+        ResultSet rs = null;
+
+        try {
+            connection = DBUtil.getConnection();
+            String sql = "select _cid, _name" +
+                ", _portrait" +
+                ", _owner" +
+                ", _secret" +
+                ", _status" +
+                ", _desc" +
+                ", _extra" +
+                ", _callback" +
+                ", _automatic" +
+                ", _menu" +
+                ", _dt from t_channel";
+            if(!withDeleted) {
+                sql += " where _status <> 64 ";
+            }
+            sql += " order by _dt desc ";
+
+            sql += " limit " + count;
+
+            if (offset > 0) {
+                sql += " offset " + offset;
+            }
+
+            statement = connection.prepareStatement(sql);
+            rs = statement.executeQuery();
+            while (rs.next()) {
+                WFCMessage.ChannelInfo.Builder builder = WFCMessage.ChannelInfo.newBuilder();
+                int index = 1;
+
+                String value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setTargetId(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setName(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setPortrait(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setOwner(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setSecret(value);
+
+                int status = rs.getInt(index++);
+                builder.setStatus(status);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setDesc(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setExtra(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setCallback(value);
+
+                int intValue = rs.getInt(index++);
+                builder.setAutomatic(intValue);
+
+                try {
+                    byte[] bytes = null;
+                    Blob blob = rs.getBlob(index++);
+                    if (blob != null) {
+                        bytes = toByteArray(blob.getBinaryStream());
+                    }
+
+                    if (bytes != null) {
+                        WFCMessage.ChannelMenuList menuButtonList = WFCMessage.ChannelMenuList.parseFrom(bytes);
+                        if (menuButtonList.getMenuCount() > 0) {
+                            for (int i = 0; i < menuButtonList.getMenuCount(); i++) {
+                                builder.addMenu(menuButtonList.getMenu(i));
+                            }
+                        }
+                    }
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+
+                long longValue = rs.getLong(index++);
+                builder.setUpdateDt(longValue);
+
+                out.add(builder.build());
+            }
+        } catch (SQLException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+            Utility.printExecption(LOG, e, RDBS_Exception);
+        } finally {
+            DBUtil.closeDB(connection, statement, rs);
+        }
+        return out;
+    }
+
+    int getChannelTotalCount(boolean withDeleted) {
+        Connection connection = null;
+        PreparedStatement statement = null;
+        ResultSet rs = null;
+
+        try {
+            connection = DBUtil.getConnection();
+            String sql = "select count(*) from t_channel";
+            if(!withDeleted) {
+                sql += " where _status <> 64";
+            }
+
+            statement = connection.prepareStatement(sql);
+            rs = statement.executeQuery();
+            if (rs.next()) {
+                return rs.getInt(1);
+            }
+        } catch (SQLException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+            Utility.printExecption(LOG, e, RDBS_Exception);
+        } finally {
+            DBUtil.closeDB(connection, statement, rs);
+        }
+        return 0;
+    }
+
+    public int getChannelListenerCount(String channelId) {
+        Connection connection = null;
+        PreparedStatement statement = null;
+        ResultSet rs = null;
+        try {
+            connection = DBUtil.getConnection();
+            String sql = "select count(*) from  t_channel_listener where _cid = ?";
+
+            statement = connection.prepareStatement(sql);
+
+            int index = 1;
+            statement.setString(index++, channelId);
+
+            rs = statement.executeQuery();
+            if (rs.next()) {
+                return rs.getInt(1);
+            }
+        } catch (SQLException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+            Utility.printExecption(LOG, e, RDBS_Exception);
+        } finally {
+            DBUtil.closeDB(connection, statement, rs);
+        }
+        return 0;
+    }
+
+    public List<String> getChannelListenerList(String channelId, int count, int offset) {
+        List<String> out = new ArrayList<>();
+        Connection connection = null;
+        PreparedStatement statement = null;
+        ResultSet rs = null;
+        try {
+            connection = DBUtil.getConnection();
+            String sql = "select  _mid from t_channel_listener where _cid = ?";
+
+            if(count > 0) {
+                sql += " limit " + count;
+            }
+
+            if(offset > 0) {
+                sql += " offset " + offset;
+            }
+
+            statement = connection.prepareStatement(sql);
+
+            int index = 1;
+            statement.setString(index++, channelId);
+
+            rs = statement.executeQuery();
+            while (rs.next()) {
+                String value = rs.getString(1);
+                if (!StringUtil.isNullOrEmpty(value)) {
+                    out.add(value);
+                }
+            }
+        } catch (SQLException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+            Utility.printExecption(LOG, e, RDBS_Exception);
+        } finally {
+            DBUtil.closeDB(connection, statement, rs);
+        }
+        return out;
+    }
+
+
    public Set<String> getSensitiveWord() {
        Connection connection = null;
        PreparedStatement statement = null;
@@ -40,6 +40,9 @@ public class MemorySessionStore implements ISessionsStore {

    private boolean supportMultiEndpoint = false;
    private boolean supportMultiPCEndpoint = false;
+    private boolean supportMultiPadEndpoint = false;
+    private boolean supportMultiWearableEndpoint = false;
+    private boolean supportMultiTVEndpoint = false;
    private boolean clientSupportKickoff = false;

    public static class Session implements Comparable<Session>{
@@ -60,6 +63,7 @@ public class MemorySessionStore implements ISessionsStore {
        private int deleted;

        private boolean pullHistoryMsg;
+        private String ip;

        public int getDeleted() {
            return deleted;
@@ -91,8 +95,16 @@ public class MemorySessionStore implements ISessionsStore {
            return unReceivedMsgs;
        }

-        public void setUnReceivedMsgs(int unReceivedMsgs) {
-            this.unReceivedMsgs = unReceivedMsgs;
+        public boolean isPcClient() {
+            return platform == ProtoConstants.Platform.Platform_Windows || platform == ProtoConstants.Platform.Platform_OSX || platform == ProtoConstants.Platform.Platform_LINUX;
+        }
+
+        public boolean isPadClient() {
+            return platform == ProtoConstants.Platform.Platform_iPad || platform == ProtoConstants.Platform.Platform_APad || platform == ProtoConstants.Platform.Platform_HarmonyPad;
+        }
+
+        public boolean isTVClient() {
+            return platform == ProtoConstants.Platform.Platform_AppleTV || platform == ProtoConstants.Platform.Platform_AndroidTV || platform == ProtoConstants.Platform.Platform_HarmonyTV;
        }

        public int getPushType() {
@@ -162,6 +174,14 @@ public class MemorySessionStore implements ISessionsStore {
            }
        }

+        public String getIp() {
+            return ip;
+        }
+
+        public void setIp(String ip) {
+            this.ip = ip;
+        }
+
        private int pushType;
        private int platform;

@@ -292,6 +312,20 @@ public class MemorySessionStore implements ISessionsStore {
            supportMultiPCEndpoint = Boolean.parseBoolean(server.getConfig().getProperty(BrokerConstants.SERVER_MULTI_PC_ENDPOINT, "false"));
        } catch (Exception e) {
        }
+        try {
+            supportMultiPadEndpoint = Boolean.parseBoolean(server.getConfig().getProperty(BrokerConstants.SERVER_MULTI_PAD_ENDPOINT, "false"));
+        } catch (Exception e) {
+        }
+
+        try {
+            supportMultiWearableEndpoint = Boolean.parseBoolean(server.getConfig().getProperty(BrokerConstants.SERVER_MULTI_WEARABLE_ENDPOINT, "false"));
+        } catch (Exception e) {
+        }
+
+        try {
+            supportMultiTVEndpoint = Boolean.parseBoolean(server.getConfig().getProperty(BrokerConstants.SERVER_MULTI_TV_ENDPOINT, "false"));
+        } catch (Exception e) {
+        }

        try {
            clientSupportKickoff = Boolean.parseBoolean(server.getConfig().getProperty(BrokerConstants.SERVER_CLIENT_SUPPORT_KICKOFF_EVENT, "false"));
@@ -396,6 +430,15 @@ public class MemorySessionStore implements ISessionsStore {
            && !(platform == ProtoConstants.Platform.Platform_Windows && supportMultiPCEndpoint)
            && !(platform == ProtoConstants.Platform.Platform_LINUX && supportMultiPCEndpoint)
            && !(platform == ProtoConstants.Platform.Platform_OSX && supportMultiPCEndpoint)
+            && !(platform == ProtoConstants.Platform.Platform_HarmonyPC && supportMultiPCEndpoint)
+            && !(platform == ProtoConstants.Platform.Platform_iPad && supportMultiPadEndpoint)
+            && !(platform == ProtoConstants.Platform.Platform_APad && supportMultiPadEndpoint)
+            && !(platform == ProtoConstants.Platform.Platform_HarmonyPad && supportMultiPadEndpoint)
+            && !(platform == ProtoConstants.Platform.Platform_AndroidWearable && supportMultiWearableEndpoint)
+            && !(platform == ProtoConstants.Platform.Platform_HarmonyWearable && supportMultiWearableEndpoint)
+            && !(platform == ProtoConstants.Platform.Platform_AndroidTV && supportMultiTVEndpoint)
+            && !(platform == ProtoConstants.Platform.Platform_AppleTV && supportMultiTVEndpoint)
+            && !(platform == ProtoConstants.Platform.Platform_HarmonyTV && supportMultiTVEndpoint)
        ) {
            databaseStore.clearMultiEndpoint(username, clientID, platform);
            if (userSessions.get(username) != null) {
@@ -410,15 +453,27 @@ public class MemorySessionStore implements ISessionsStore {
                        }

                        boolean remove = false;
-                        if (platform == ProtoConstants.Platform.Platform_Android || platform == ProtoConstants.Platform.Platform_iOS) {
-                            if (s.getPlatform() == ProtoConstants.Platform.Platform_Android || s.getPlatform() == ProtoConstants.Platform.Platform_iOS) {
+                        if (platform == ProtoConstants.Platform.Platform_Android || platform == ProtoConstants.Platform.Platform_iOS || platform == ProtoConstants.Platform.Platform_Harmony) {
+                            if (s.getPlatform() == ProtoConstants.Platform.Platform_Android || s.getPlatform() == ProtoConstants.Platform.Platform_iOS || s.getPlatform() == ProtoConstants.Platform.Platform_Harmony) {
                                remove = true;
                            }
-                        } else if(platform == ProtoConstants.Platform.Platform_OSX || platform == ProtoConstants.Platform.Platform_Windows || platform == ProtoConstants.Platform.Platform_LINUX) {
-                            if (s.getPlatform() == ProtoConstants.Platform.Platform_OSX || s.getPlatform() == ProtoConstants.Platform.Platform_Windows || s.getPlatform() == ProtoConstants.Platform.Platform_LINUX) {
+                        } else if(platform == ProtoConstants.Platform.Platform_iPad || platform == ProtoConstants.Platform.Platform_APad || platform == ProtoConstants.Platform.Platform_HarmonyPad) {
+                            if (s.getPlatform() == ProtoConstants.Platform.Platform_iPad || s.getPlatform() == ProtoConstants.Platform.Platform_APad || s.getPlatform() == ProtoConstants.Platform.Platform_HarmonyPad) {
                                remove = true;
                            }
-                        } else {
+                        } else if(platform == ProtoConstants.Platform.Platform_OSX || platform == ProtoConstants.Platform.Platform_Windows || platform == ProtoConstants.Platform.Platform_LINUX || platform == ProtoConstants.Platform.Platform_HarmonyPC) {
+                            if (s.getPlatform() == ProtoConstants.Platform.Platform_OSX || s.getPlatform() == ProtoConstants.Platform.Platform_Windows || s.getPlatform() == ProtoConstants.Platform.Platform_LINUX || s.getPlatform() == ProtoConstants.Platform.Platform_HarmonyPC) {
+                                remove = true;
+                            }
+                        } else if(platform == ProtoConstants.Platform.Platform_AndroidWearable || platform == ProtoConstants.Platform.Platform_HarmonyWearable) {
+                            if (s.getPlatform() == ProtoConstants.Platform.Platform_AndroidWearable || s.getPlatform() == ProtoConstants.Platform.Platform_HarmonyWearable) {
+                                remove = true;
+                            }
+                        } else if(platform == ProtoConstants.Platform.Platform_AndroidTV || platform == ProtoConstants.Platform.Platform_AppleTV || platform == ProtoConstants.Platform.Platform_HarmonyTV) {
+                            if (s.getPlatform() == ProtoConstants.Platform.Platform_AndroidTV || s.getPlatform() == ProtoConstants.Platform.Platform_AppleTV || s.getPlatform() == ProtoConstants.Platform.Platform_HarmonyTV) {
+                                remove = true;
+                            }
+                        } else { //web, microapp
                            if (s.getPlatform() ==platform) {
                                remove = true;
                            }
@@ -535,6 +590,15 @@ public class MemorySessionStore implements ISessionsStore {
        return session.clientSession;
    }

+    @Override
+    public void updateSessionIp(String username, String clientID, String ip) {
+        Session session = getSession(clientID);
+        if(session != null && session.getDeleted() == 0) {
+            session.setIp(ip);
+            databaseStore.updateSessionIp(username, clientID, ip);
+        }
+    }
+
    @Override
    public Session sessionForClientAndUser(String username, String clientID) {
        Session session = sessions.get(clientID);
@@ -747,7 +811,12 @@ public class MemorySessionStore implements ISessionsStore {
            if (session.getPlatform() == ProtoConstants.Platform.Platform_LINUX
                || session.getPlatform() == ProtoConstants.Platform.Platform_WEB
                || session.getPlatform() == ProtoConstants.Platform.Platform_Windows
-                || session.getPlatform() == ProtoConstants.Platform.Platform_OSX) {
+                || session.getPlatform() == ProtoConstants.Platform.Platform_OSX
+                || session.getPlatform() == ProtoConstants.Platform.Platform_HarmonyPC
+                || session.getPlatform() == ProtoConstants.Platform.Platform_iPad
+                || session.getPlatform() == ProtoConstants.Platform.Platform_APad
+                || session.getPlatform() == ProtoConstants.Platform.Platform_HarmonyPad
+            ) {
                databaseStore.updateSessionDeleted(operator, pcClientId, 1);
                sessions.remove(pcClientId);
                mServer.getProcessor().kickoffSession(session);
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
heavyrian2012	cfcd8fc276	更新版本号和release note	2026-06-13 10:18:18 +08:00
heavyrian2012	457f417a52	同步专业版server sdk添加获取用户未读数接口	2026-06-13 10:13:19 +08:00
heavyrian2012	b2536992b6	优化文件上传的认证	2026-06-08 12:07:38 +08:00
heavyrian2012	c7102d5dc3	解决serverapi获取频道列表缺少字段的问题	2026-06-05 15:29:25 +08:00
heavyrian2012	fd0ee5c674	添加配置支持机器人和频道应用不校验host	2026-05-18 20:22:31 +08:00
heavyrian2012	af85b08f94	添加会议总结消息	2026-05-18 15:53:17 +08:00
heavyrian2012	de89b44b21	release note and version	2026-05-10 15:12:17 +08:00
heavyrian2012	44b18a66c0	优化批量添加频道订阅功能	2026-05-10 14:55:55 +08:00
heavyrian2012	42281c3ad3	添加部分频道相关server api	2026-05-10 14:30:59 +08:00
heavyrian2012	776c9e26c6	机器人API添加根据邮箱获取用户信息和批量获取用户信息的接口	2026-04-29 15:31:59 +08:00
heavyrian2012	c7f7ce949e	机器人和频道api，请求错误时，result应该为空	2026-04-26 09:42:22 +08:00
heavyrian2012	07b1de4ae3	添加注释	2026-04-20 08:19:38 +08:00
heavyrian2012	7e87f9d6ab	机器人更新消息内容添加distribute接口	2026-04-19 20:06:53 +08:00
heavyrian2012	da781180a7	解决业务系统不限制手机号码重复时，根据手机号码获取用户列表的问题	2026-04-10 21:53:24 +08:00
heavyrian2012	f1b62ad64a	同步专业版数据库	2026-04-10 21:41:49 +08:00
heavyrian2012	576fcf3e77	添加获取所有机器人的接口	2026-04-05 11:28:46 +08:00
heavyrian2012	33f2124352	同步专业版IM服务SDK	2026-03-31 15:57:29 +08:00
heavyrian2012	15701e9943	version and release note	2026-03-25 10:04:24 +08:00
heavyrian2012	dc5687319a	转移群组时判断是否已经是群主	2026-03-25 10:01:15 +08:00
heavyrian2012	3eef24bdb9	添加server sdk readme	2026-03-15 10:30:00 +08:00
heavyrian2012	be5a24a6fd	update readme	2026-03-13 13:02:17 +08:00
heavyrian2012	6537b7e009	getPresignedUploadUrl公开	2026-03-11 16:15:47 +08:00
heavyrian2012	92471db413	添加SDK上传功能	2026-03-11 16:11:13 +08:00
heavyrian2012	6626237c80	支持可穿戴设备和TV端	2026-03-06 19:15:22 +08:00
heavyrian2012	c98507d9a0	sdk测试方法中添加更多的测试例	2026-03-04 19:16:35 +08:00
heavyrian2012	d8adaf7e88	启动脚本里添加utf8参数	2026-02-28 21:33:38 +08:00
imndx	45d40e2389	update readme	2026-02-27 10:03:30 +08:00
heavyrian2012	33de0f3e43	添加网盘对象存储	2026-02-26 14:20:02 +08:00
heavyrian2012	a9300e8ecc	version and release note	2026-02-24 10:50:22 +08:00
heavyrian2012	368388e7bd	fix build error	2026-02-24 10:40:02 +08:00
heavyrian2012	969de83e1f	只有在重新登录的时候清除锁定	2026-02-24 10:37:21 +08:00
heavyrian2012	8f74e54c88	添加锁定PC的设置，当离线时自动解除	2026-02-23 11:50:32 +08:00
heavyrian2012	efd9d5519f	敏感词命中时日志打印出命中的敏感词。	2026-02-09 17:41:33 +08:00
heavyrian2012	97b6ccb910	好友关系表添加索引	2026-02-08 11:02:16 +08:00
heavyrian2012	c51f523d6e	添加注释	2026-02-04 10:39:34 +08:00
heavyrian2012	298ce69db7	调整文件目录	2026-02-04 09:07:20 +08:00
heavyrian2012	15c2d8f59e	update	2026-02-04 09:02:45 +08:00
heavyrian2012	8322134e18	1，解决删除用户保留信息时错误问题；2，server api获取用户信息时，可以指定获取包含被删除用户。	2026-02-03 19:51:03 +08:00
heavyrian2012	52b624f25e	update version and release note	2026-02-03 11:30:46 +08:00
heavyrian2012	d90bab53ad	添加配置在机器人获取用户信息时指定获取字段	2026-02-03 11:24:28 +08:00
heavyrian2012	4d60231c8c	1，添加获取用户机器人列表ID的接口。 2，机器人回调消息中添加回调的机器人ID。 3，mesh服务添加加群申请相关接口	2026-02-02 13:48:04 +08:00
heavyrian2012	d08d6f0c49	解决创建用户没有传昵称参数时使用了账户的问题	2026-01-27 20:30:02 +08:00
heavyrian2012	effa30b546	添加修改好友extra接口	2026-01-26 13:09:22 +08:00
heavyrian2012	0f688ff1df	mesh发布消息时添加messageId参数	2026-01-25 11:24:48 +08:00
heavyrian2012	daa4767ed8	update version and release note	2026-01-20 10:35:22 +08:00
heavyrian2012	44a916892b	解决server sdk有内存泄漏的问题	2026-01-20 10:30:28 +08:00
heavyrian2012	51dd94d3a7	同步专业版IM服务数据库	2026-01-08 15:57:52 +08:00
heavyrian2012	2609a4251c	同步专业版Server SDK	2025-12-31 22:15:34 +08:00
heavyrian2012	7d36775c27	添加客户预留对象存储文件类型	2025-12-25 16:02:38 +08:00
heavyrian2012	6c9df5c071	接受好友请求后发的通知的发送者改为接受者发送	2025-12-17 09:38:55 +08:00
heavyrian2012	2f9c4e028c	解决上传文件中的逻辑问题	2025-12-02 14:46:00 +08:00
heavyrian2012	a9b83a14ed	update readme	2025-12-01 15:07:15 +08:00
heavyrian2012	919b81139d	update version and release note	2025-11-30 19:25:45 +08:00
heavyrian2012	52959a5e63	解决有些平台解析文本消息解析不出来的问题	2025-11-30 19:13:13 +08:00
heavyrian2012	31dad28fde	update version and release note	2025-11-23 14:02:19 +08:00
heavyrian2012	3094089658	添加搜索限频配置	2025-11-23 13:59:11 +08:00
heavyrian2012	24d24fe1e9	添加配置当销毁用户时是否销毁用户信息和消息	2025-11-22 23:02:56 +08:00
heavyrian2012	47039f53b2	群组成员表添加一个索引	2025-11-20 11:51:17 +08:00
heavyrian2012	554243d553	解决移动平台多端未收消息计数重复的问题	2025-11-20 11:41:54 +08:00
heavyrian2012	b65282f8e2	更新readme	2025-11-13 22:36:41 +08:00
heavyrian2012	a5f64df2de	update version and release note	2025-11-09 11:42:48 +08:00
heavyrian2012	c7f1ea57dc	解决某些平台SDK内置消息没有注册的问题	2025-11-06 18:31:12 +08:00
heavyrian2012	c9b2de076d	默认用户ID搜索用户功能开启	2025-10-31 07:31:57 +08:00
heavyrian2012	552fadaa87	记录客户端来源IP地址	2025-10-26 16:57:33 +08:00
heavyrian2012	765572db36	移除掉无用的编译plugin，解决java8编译错误问题	2025-10-13 09:57:32 +08:00
heavyrian2012	a5f194b385	server api测试代码默认为社区版	2025-10-13 09:56:56 +08:00
heavyrian2012	c74cd7e290	解决server sdk解析图片消息不带缩略图解析错误问题	2025-09-29 20:39:12 +08:00
heavyrian2012	70cf65f0c0	解决Server SDK发送引用消息客户端无法正确解析的问题	2025-09-20 09:41:29 +08:00
heavyrian2012	3bb23f92c4	update version and release note	2025-09-07 09:44:42 +08:00
heavyrian2012	804c12845e	fix error	2025-09-06 23:33:35 +08:00
heavyrian2012	fe15a32499	添加开关是否开启允许@不在会话中的机器人	2025-09-06 23:29:09 +08:00
heavyrian2012	06d168935d	支持@不在群组中的机器人和单人会话支持@机器人，支持机器人回复。	2025-09-06 21:36:29 +08:00
heavyrian2012	c1984d27b3	同步专业版SDK	2025-09-05 20:53:32 +08:00
heavyrian2012	29ef46b7a0	解决机器人和频道sdk检查端口错误提示的问题	2025-09-05 20:53:12 +08:00
heavyrian2012	0bdff3fd89	同步专业版server sdk	2025-08-30 10:18:34 +08:00
heavyrian2012	cd03583dab	解决server sdk反复初始化时内存泄漏问题	2025-08-25 11:11:12 +08:00
heavyrian2012	3f8fd7e5e0	update version and release note	2025-08-17 14:46:20 +08:00
heavyrian2012	fdfe71f700	server api添加群备注和收藏群组接口	2025-08-17 14:45:38 +08:00
heavyrian2012	35ecf7ccc6	发送消息的server api添加参数，可以以用户权限发送消息	2025-08-17 10:51:39 +08:00
heavyrian2012	8f798742c3	同步专业版sdk	2025-08-17 10:51:08 +08:00
heavyrian2012	f4ea8b184c	如果server sdk没有初始化，打印出初始化的代码和提示	2025-08-12 12:19:52 +08:00
heavyrian2012	2d7f344b1a	可以系统设置里设置那么名字不能被使用	2025-08-05 17:11:00 +08:00
heavyrian2012	bee03cd2f8	添加配置敏感词检查用户昵称/群组名/群备注等信息	2025-08-05 15:32:20 +08:00
heavyrian2012	59b1c3180f	现在发送消息大小不能超过64KB	2025-08-03 18:04:12 +08:00
heavyrian2012	88d764fb6d	update version and release note	2025-08-02 10:45:59 +08:00
heavyrian2012	08b3886238	解决机器人回调配置带上发送人信息功能无效问题	2025-08-02 10:38:09 +08:00
heavyrian2012	7e73c2880b	支持客户端上传本地角标，当需要推送时会把角标数字带上	2025-07-29 11:51:11 +08:00
heavyrian2012	1359ce5250	解决上传文件可能内存泄漏的问题	2025-07-18 21:17:13 +08:00
heavyrian2012	56eaf938a8	添加注释	2025-07-16 17:50:18 +08:00
heavyrian2012	6ef6ed2906	添加群组成员时支持部分成员失败	2025-07-05 16:47:15 +08:00
heavyrian2012	63f37e8984	更新sdk接口测试的说明	2025-07-04 14:03:06 +08:00
heavyrian2012	337302c551	update readme	2025-06-29 11:32:04 +08:00
heavyrian2012	721f27a58a	搜索用户可以指定搜索用户或者机器人	2025-06-22 14:59:34 +08:00
heavyrian2012	ced74280d8	version and release note	2025-06-19 19:19:21 +08:00
heavyrian2012	18617c67f4	api/version和gettoken都添加节点信息	2025-06-19 19:15:35 +08:00
heavyrian2012	883866ce39	配置文件添加注释	2025-06-17 16:02:40 +08:00
heavyrian2012	2e135d4794	群组成员表添加一条索引	2025-06-14 12:38:16 +08:00
heavyrian2012	1d6faa5796	server api支持修改群组类型	2025-05-29 14:18:29 +08:00
heavyrian2012	731fa00cc9	创建/更新频道接口添加频道菜单属性	2025-05-12 14:27:07 +08:00
heavyrian2012	4da9173c5f	修改撤回时间配置，可以配置为不允许撤回	2025-05-10 08:12:20 +08:00
heavyrian2012	94e430cc83	解决外置消息审核回调没有回调成功的问题	2025-05-05 16:52:19 +08:00
heavyrian2012	7e92d1e0c5	Server API创建频道时，需要同时返回频道ID和频道密钥	2025-04-25 23:10:43 +08:00
heavyrian2012	4fa79bfeac	频道和机器人API添加对端口的检查提示	2025-04-22 12:21:45 +08:00
heavyrian2012	98388a5129	update version and release note	2025-04-18 20:03:38 +08:00
heavyrian2012	1a89714df9	配置文件中群组标记删除默认开启	2025-04-18 19:59:37 +08:00
heavyrian2012	a855652c26	音视频通话挂断时推送数据包含开始通话的消息UID	2025-04-18 11:12:15 +08:00
heavyrian2012	21aadd9c0b	去掉空的echo	2025-04-14 10:42:26 +08:00
heavyrian2012	5522a8689d	server api添加日志	2025-04-13 18:26:07 +08:00
heavyrian2012	bf52a00304	添加配置是否允许发送消息给被封禁用户	2025-04-12 14:00:55 +08:00
heavyrian2012	3349e2a4e5	添加server api发送朋友圈的api	2025-04-12 12:54:34 +08:00
heavyrian2012	70f3f96f7a	server sdk添加撤回和删除消息	2025-04-12 09:57:10 +08:00
heavyrian2012	5e9d411f1b	内置存储支持在线播放	2025-04-09 16:40:37 +08:00
heavyrian2012	e74fd0c660	添加配置，转发消息时是否代码发送者信息和目标信息	2025-03-27 20:52:12 +08:00
heavyrian2012	d1232abe39	version and release note	2025-03-05 19:20:54 +08:00
heavyrian2012	1df192f730	解决分段拉取消息时可能丢消息的问题	2025-03-05 19:13:29 +08:00
heavyrian2012	f897e640fc	SDK添加超时配置	2025-03-03 12:11:19 +08:00
heavyrian2012	ee6e4f96fb	配置允许撤回消息时间小于等于0时可以允许用户任意时间撤回消息	2025-02-21 19:28:57 +08:00
heavyrian2012	d14dc74566	sdk添加注册消息的接口，可以允许sdk注册自定义消息	2025-02-19 19:27:42 +08:00
heavyrian2012	ff75379779	优化server sdk	2025-02-18 09:53:34 +08:00
heavyrian2012	b95a6b7785	更新版本号和Release note	2025-02-13 19:00:39 +08:00
heavyrian2012	5acb3044ac	Revert "serveri api获取用户信息时返回deleted字段" This reverts commit `ae084063f4`.	2025-01-24 10:34:53 +08:00
heavyrian2012	ae084063f4	serveri api获取用户信息时返回deleted字段	2025-01-23 16:27:36 +08:00
heavyrian2012	cb3a82559d	机器人API添加定向消息参数	2025-01-17 20:17:18 +08:00
heavyrian2012	9191204bb0	nginx配置注释	2025-01-15 10:07:37 +08:00
heavyrian2012	6587a88ca9	修改注释	2025-01-14 11:07:39 +08:00
heavyrian2012	86c1a2e140	转移群主时检查目标用户是否在群组中	2025-01-03 21:33:46 +08:00
heavyrian2012	83e9679339	SDK的地址和密钥添加trim，避免空格换行等问题	2025-01-02 14:23:23 +08:00
heavyrian2012	dafb0cd4d9	修改nginx配置示例中上传文件的大小为200MB	2024-12-26 08:42:24 +08:00
heavyrian2012	cbcc8310c4	敏感词过滤类型默认改成2	2024-12-15 10:47:45 +08:00
heavyrian2012	ade58efc11	更新版本号和release note内容	2024-12-11 16:28:51 +08:00
heavyrian2012	d45da9674e	默认开启支持支持踢出事件的开关	2024-12-11 16:24:19 +08:00
heavyrian2012	f603a677ea	当禁止私聊时可以配置例外的线路	2024-12-06 16:06:04 +08:00
heavyrian2012	03894aea9a	修改启动成功的提示语	2024-12-06 08:02:30 +08:00
heavyrian2012	8635153e59	解决聊天室定向消息问题	2024-11-20 12:47:11 +08:00
heavyrian2012	3d98d17b0d	机器人接口添加更新朋友圈接口	2024-11-14 12:51:05 +08:00
heavyrian2012	0549bc502f	添加批量获取用户信息的接口	2024-11-14 12:50:38 +08:00
heavyrian2012	1b8cf3e5f9	添加机器人的朋友圈接口	2024-11-03 10:06:10 +08:00
heavyrian2012	f3f08b3026	version & release note	2024-10-30 19:12:31 +08:00
heavyrian2012	78e6efce14	透传消息需要带上时间戳	2024-10-30 19:00:35 +08:00
heavyrian2012	462423a6f3	SDK添加删除广播和组播接口	2024-10-28 22:08:20 +08:00
heavyrian2012	55190a4f76	优化生成测试数据工具	2024-10-26 14:13:56 +08:00
heavyrian2012	4ed21ecb03	添加生成测试工具的工具	2024-10-25 14:43:06 +08:00
heavyrian2012	1ff3b592bd	创建群组时检查操作者参数是不是存在	2024-10-25 14:42:55 +08:00
heavyrian2012	fbc2351d82	用户可以设置禁止添加好友	2024-10-02 20:07:17 +08:00
heavyrian2012	dd1783d4ac	透传消息去掉消息id和时间戳，减少消息体大小	2024-10-02 20:04:47 +08:00
heavyrian2012	845e6ff8aa	version and release note	2024-09-29 08:18:17 +08:00
heavyrian2012	6d91f3869e	创建群组或者添加群组成员时，群组成员的Extra会放到通知消息的extra中，这样便于业务处理通知消息	2024-09-25 11:07:12 +08:00
heavyrian2012	d100bd5fb1	update readme	2024-09-18 20:19:15 +08:00
heavyrian2012	bf22b365a8	如果没有配置鸿蒙推送地址，不应该回落到Android，避免对android造成影响	2024-09-18 13:01:49 +08:00
heavyrian2012	f1298a51ae	添加鸿蒙推送回调地址	2024-09-18 12:50:19 +08:00
heavyrian2012	41f62c6354	添加配置，是否允许发送消息给黑名单用户	2024-09-14 09:53:50 +08:00
heavyrian2012	a45de0ecd1	添加好友请求限频功能	2024-09-12 21:34:12 +08:00
heavyrian2012	fc35865478	push message 添加 republish 属性	2024-09-12 21:29:03 +08:00
heavyrian2012	b1f59498e5	version and release note	2024-09-10 10:57:15 +08:00
heavyrian2012	04f5471385	用户id默认使用uuid	2024-09-10 10:53:21 +08:00
heavyrian2012	291fdfb08d	解决server api获取群组信息不全的问题	2024-09-03 14:58:00 +08:00
heavyrian2012	52de13e20d	sdk中针对密钥错误给出提醒	2024-08-22 20:42:22 +08:00
heavyrian2012	c1d353bce9	version & release note	2024-08-19 09:28:38 +08:00
heavyrian2012	9d83f8e3fa	解决某些时候http请求返回信息无法读取问题	2024-08-14 08:35:39 +08:00
heavyrian2012	94833780ef	update readme	2024-08-12 08:35:32 +08:00
heavyrian2012	d0fdf55db4	群组解散后撤回失败的错误码应该是不存在	2024-07-29 11:45:35 +08:00
heavyrian2012	ea00ef6b7f	添加发送消息的示例	2024-07-19 16:54:15 +08:00
heavyrian2012	a11cf3c564	解决群组标记删除错误	2024-07-19 16:24:36 +08:00
heavyrian2012	f5af956298	更新readme	2024-07-19 09:41:55 +08:00
heavyrian2012	4005a4babe	配置文件注释说明	2024-07-10 11:14:07 +08:00
heavyrian2012	6ef8b78452	server api获取被封禁用户时，过滤掉正常用户	2024-07-09 16:06:10 +08:00
heavyrian2012	100a1bd44c	update readme	2024-07-07 11:02:38 +08:00
heavyrian2012	5a213704c5	version and release note	2024-06-30 12:17:37 +08:00
heavyrian2012	5a52a7d553	同步专业版IM服务	2024-06-30 12:13:21 +08:00
heavyrian2012	d751a7080b	添加Mesh相关SDK	2024-06-21 16:45:10 +08:00
heavyrian2012	68ae7dbd58	SDK中关于频道的api放到ChannelAdmin方法中	2024-06-11 09:10:17 +08:00
heavyrian2012	10fce4baad	解决机器人API修改机器人用户信息客户端没有更新的问题	2024-06-11 08:47:42 +08:00
heavyrian2012	c69906e249	添加频道新的回调特性	2024-05-29 16:30:54 +08:00
heavyrian2012	1aed4b1d37	搜索频道时，解决某些频道不能搜索出来的问题	2024-05-29 16:08:37 +08:00
heavyrian2012	f2601fc65d	针对非x86_64平台关于epoll的说明	2024-05-07 12:32:37 +08:00
heavyrian2012	4895f03a68	version and release note	2024-05-05 15:36:06 +08:00
heavyrian2012	1d234a3575	获取被删除群组时总是同步	2024-04-28 17:11:36 +08:00
heavyrian2012	386d0b9c57	删除无用代码	2024-04-27 08:35:55 +08:00
heavyrian2012	3ab1c7553d	如果用户不在群中，不再进行群组信息更新	2024-04-25 10:45:21 +08:00
heavyrian2012	85a4c806c1	退群时添加是否保留消息的参加	2024-04-25 10:44:50 +08:00
heavyrian2012	9aac87b7a1	拉取消息时，处理重复消息	2024-04-23 14:17:40 +08:00
heavyrian2012	ce21441772	群主强制被退群时（销毁账号/server api强制退群），调整新群主选择，群管理优先，先加入群组优先。	2024-04-23 13:28:53 +08:00
heavyrian2012	0a3516cdf2	version and release note	2024-04-19 11:28:17 +08:00
heavyrian2012	135a9ed0a8	添加用户设置添加好友验证功能	2024-04-19 11:19:43 +08:00
heavyrian2012	73e3447b39	强制推送配置默认为关闭	2024-04-03 10:51:06 +08:00
heavyrian2012	394b9119fa	添加配置，可以在会话静音/全局静音/PC在线时静音时强制推送。 (cherry picked from commit 1f4cf54990831d4bcc4fcec2fa5479036a581e58)	2024-04-03 10:49:47 +08:00
heavyrian2012	ebb05351a8	群组标记删除 (cherry picked from commit cdf4a0c011b879819c0263b84bddd2da5cb8bc7d)	2024-04-03 10:49:46 +08:00
heavyrian2012	c4421fc9ed	server api添加通过邮箱获取用户列表的接口	2024-03-25 19:00:42 +08:00
heavyrian2012	a906bf352d	version and release note	2024-03-25 09:04:28 +08:00
heavyrian2012	37f1772705	在线状态回调添加其他端的状态	2024-03-23 12:32:45 +08:00
heavyrian2012	0a05503c78	创建频道和机器人时，不再设置默认头像	2024-03-23 11:13:37 +08:00
heavyrian2012	a702602758	去掉用户信息中的密码处理	2024-03-23 11:13:09 +08:00
heavyrian2012	c01e5b634d	version and release note	2024-03-07 16:33:50 +08:00
heavyrian2012	6c2848cbf7	升级依赖	2024-02-27 20:45:14 +08:00
heavyrian2012	ae3c8e0d25	升级部分依赖版本	2024-02-27 11:51:48 +08:00
heavyrian2012	2ef0059395	remove useless test code	2024-02-27 11:28:28 +08:00
heavyrian2012	d91a2d9fd5	升级部分依赖版本	2024-02-27 11:27:56 +08:00
heavyrian2012	a4bcd5e29e	同步专业版IM服务	2024-02-22 14:28:49 +08:00
heavyrian2012	fe4612c801	解决server端音视频SDK信令透传问题	2024-02-22 14:26:04 +08:00
heavyrian2012	58ade23b23	添加鸿蒙平台的支持	2024-02-04 17:02:20 +08:00
heavyrian2012	f1e46fca75	同步专业版IM服务	2024-02-02 13:44:47 +08:00
heavyrian2012	1e17fa1db4	同步专业版IM SDK	2024-02-02 12:50:23 +08:00
heavyrian2012	7094114ea3	同步专业版IM服务SDK	2024-01-27 14:13:14 +08:00
				`@@ -0,0 +1,2 @@`
				alter table `t_group` add column `_deleted` tinyint NOT NULL DEFAULT 0;
				`@@ -0,0 +1 @@`
				CREATE INDEX `user_gid_dt_index` ON `t_group_member` (`_gid`, `_dt`);
				`@@ -0,0 +1 @@`
				insert into t_settings(`id`, `_value`,`_desc`) values (2, '文件传输助手,客服,官方', '禁止使用名称，如果有多个，以英文逗号隔开。直接修改数据库，不用重启IM服务');
				`@@ -0,0 +1 @@`
				alter table `t_messages` modify column `_target` varchar(129) NOT NULL;
				`@@ -0,0 +1 @@`
				ALTER TABLE `t_user_session` ADD COLUMN `_ip` varchar(40) DEFAULT '';
				`@@ -0,0 +1 @@`
				CREATE INDEX `user_gid_type_index` ON `t_group_member` (`_gid`, `_type`);
				`@@ -0,0 +1 @@`
				alter table t_friend add index `friend_uid_index` (`_friend_uid`);
				`@@ -0,0 +1 @@`
				CREATE INDEX `user_gid_mid_dt_index` ON `t_group_member` (`_gid`, `_mid`, `_dt`);