version 0.75

update
机器人不允许获取token和登录
2021-11-17 16:30:25 +08:00 · 2021-11-16 16:50:48 +08:00 · 2021-11-16 16:49:09 +08:00 · 2021-11-10 11:30:06 +08:00 · 2021-11-04 15:00:43 +08:00 · 2021-10-26 10:11:05 +08:00
168 changed files with 3548 additions and 722 deletions
@@ -1,22 +1,27 @@
 ## 野火IM解决方案

-野火IM是一套跨平台、核心功能开源的即时通讯解决方案，主要包含以下内容。
+野火IM是专业级即时通讯和实时音视频整体解决方案，由北京野火无限网络科技有限公司维护和支持。
+
+主要特性有：私有部署安全可靠，性能强大，功能齐全，全平台支持，开源率高，部署运维简单，二次开发友好，方便与第三方系统对接或者嵌入现有系统中。详细情况请参考[在线文档](https://docs.wildfirechat.cn)。
+
+主要包括一下项目：
+
+| [GitHub仓库地址(主站)](https://github.com/wildfirechat)      | [码云仓库地址(镜像)](https://gitee.com/wfchat)        | 说明                                                                                      | 备注                                           |
+| ------------------------------------------------------------ | ----------------------------------------------------- | ----------------------------------------------------------------------------------------- | ---------------------------------------------- |
+| [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/pc-chat)           | [pc-chat](https://gitee.com/wfchat/pc-chat)           | 基于[Electron](https://electronjs.org/)开发的PC平台应用                                   |                                                |
+| [web-chat](https://github.com/wildfirechat/web-chat)         | [web-chat](https://gitee.com/wfchat/web-chat)         | Web平台的Demo, [体验地址](http://web.wildfirechat.cn)                                     |                                                |
+| [wx-chat](https://github.com/wildfirechat/wx-chat)           | [wx-chat](https://gitee.com/wfchat/wx-chat)           | 微信小程序平台的Demo                                                                      |                                                |
+| [server](https://github.com/wildfirechat/server)             | [server](https://gitee.com/wfchat/server)             | IM server                                                                                 |                                                |
+| [app server](https://github.com/wildfirechat/app_server)     | [app server](https://gitee.com/wfchat/app_server)     | 应用服务端                                                                                |                                                |
+| [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)   | 推送服务器                                                                                |                                                |
+| [docs](https://github.com/wildfirechat/docs)                 | [docs](https://gitee.com/wfchat/docs)                 | 野火IM相关文档，包含设计、概念、开发、使用说明，[在线查看](https://docs.wildfirechat.cn/) |                                                |  |

-| 仓库                                                         | 说明                                                    | 备注 |
-| ------------------------------------------------------------ | ------------------------------------------------------- | ---- |
-| [android-chat](https://github.com/wildfirechat/android-chat) | 野火IM Android SDK源码和App源码                       |可以很方便地进行二次开发，或集成到现有应用当中      |
-| [ios-chat](https://github.com/wildfirechat/ios-chat)         | 野火IM iOS SDK源码和App源码                            |可以很方便地进行二次开发，或集成到现有应用当中      |
-| [pc-chat](https://github.com/wildfirechat/pc-chat)           | 基于[Electron](https://electronjs.org/)开发的PC平台应用 |      |
-| [web-chat](https://github.com/wildfirechat/web-chat)          | Web平台的Demo, [体验地址](http://web.wildfirechat.net)   |      |
-| [wx-chat](https://github.com/wildfirechat/wx-chat)           | 微信小程序平台的Demo   |      |
-| [server](https://github.com/wildfirechat/server)             | IM server                                               |      |
-| [app server](https://github.com/wildfirechat/app_server)     | 应用服务端                                          |      |
-| [robot_server](https://github.com/wildfirechat/robot_server) | 机器人服务端                                        |      |
-| [push_server](https://github.com/wildfirechat/push_server)   | 推送服务器                                              |      |
-| [docs](https://github.com/wildfirechat/docs)                 | 野火IM相关文档，包含设计、概念、开发、使用说明          |      | |                                            |

 # server
-本工程为野火IM 社区版IM服务软件。野火IM作为一个通用的即时通讯解决方案，可以集成到各种应用中。请阅读[docs](http://docs.wildfirechat.net)或下载服务器[发布版本](https://github.com/wildfirechat/server/releases)
+本工程为野火IM 社区版IM服务软件。野火IM作为一个通用的即时通讯解决方案，既可以直接使用，也可以集成到各种应用中。


 开发一套IM系统真的很艰辛，请路过的朋友们给点个star，支持我们坚持下去🙏🙏🙏🙏🙏
@@ -85,4 +90,3 @@
 ## License

 1. Under the Creative Commons Attribution-NoDerivs 3.0 Unported license. See the [LICENSE](https://github.com/wildfirechat/server/blob/wildfirechat/LICENSE) file for details.
-2. Under the Anti 996 License. See the [Anti 996 LICENSE](https://github.com/wildfirechat/server/blob/wildfirechat/LICENSE_996) file for details.
@@ -13,6 +13,10 @@
        </join>
    </network>

+    <properties>
+        <property name="hazelcast.logging.type">slf4j</property>
+    </properties>
+
    <!-- map eviction -->
    <!-- http://docs.hazelcast.org/docs/latest-development/manual/html/Distributed_Data_Structures/Map/Map_Eviction.html -->
    <map name="messages_map">
@@ -11,13 +11,13 @@
 #*********************************************************************
 #服务器的接入IP。给客户端提供是${server.ip}和${http_port}。
 #客户端会从${http_port}端口获取到长链接端口。这个地址一定要改成客户端可以访问到的IP地址
-# （如果您部署云服务器上或者具有独立公网出口的服务器上，请改为对应的公网IP；如果您部署在在内网环境下，在内网使用，这个地方改成内网地址）
+#（如果您部署云服务器上或者具有独立公网出口的服务器上，请改为对应的公网IP；如果您部署在在内网环境下，在内网使用，这个地方改成内网地址）
 server.ip 192.168.3.124

 ##原生客户端长链接端口
 port 1883

-##客户端短链接端口
+##客户端短链接端口，客户端固定使用80端口，不要修改此端口。
 http_port 80

 #管理端口
@@ -32,15 +32,15 @@ host 0.0.0.0
 ##本地绑定端口
 local_port 80

-##是否使用内置DB。0使用mysql；1使用h2db；2使用mysql+mongodb。社区版只支持0和1，专业版支持2
+##是否使用内置DB。0使用mysql；1使用h2db。
 embed.db 1

 ## 是否自动清理历史消息记录，当为true时，IM服务会定时扫描t_messages_x和t_user_messages_x表，清除掉3年前的历史消息。
 ## 如果不开启自动清理，需要手动清理t_messages_x和t_user_messages_x表内的历史数据，保存数据不能超过3年。
-## 使用mongodb时次开关无效（因为mongodb设置了消息过期时间，会自动清理）。
+## 使用mongodb时次开关无效（因为mongodb设置了消息过期时间，会自动清理，仅专业版支持mongodb）。
 db.auto_clean_history_messages true

-##服务器管理接口密钥
+##服务器管理接口密钥。如果修改此端口需要同步修改使用管理API的地方，比如应用服务。
 http.admin.secret_key 123456

 ##服务器API接口参数是否检查时间。当设置为false时，所有的请求会检查时间的有效性；当设置为true时，可以在http.admin.secret_key保持不变的情况下，使用固定的服务API签名
@@ -74,14 +74,21 @@ message.blacklist.strategy 0
 ##是否禁止服务器端消息搜索，该功能暂未实现。目前的影响是如果打开，则存储消息时不单独保存_searchable_content字段
 message.disable_remote_search  false

-##允许客户端撤回用户自己发送的消息时限，单位是秒。群组管理员或群主撤回群成员消息、server api不受此限制，可以撤回任意时限内的消息
+##是否数据库中加密消息内容。注意这个开关在服务运行起来后不能改变了，避免读取数据库时无法恢复历史消息。
+##如果要避免数据库中明文存储消息内容，请打开这个开关和message.disable_remote_search开关
+message.encrypt_message_content false
+
+##允许客户端撤回用户自己发送的消息时限，单位是秒。
+##Server API不受此限制，可以撤回任意时限内的消息
+##群组管理员或群主撤回群成员消息不受此限制，可以撤回任意时限内的消息。但管理员或群主撤回自己的消息还是需要准守此时间限制。
+##修改此参数需要同步修改客户端UI，客户端UI代码有判断撤回是否显示的逻辑。
 message.recall_time_limit 120

-##禁止群主/群管理员撤回群内消息，关闭时群主/群管理员可以撤回任意时间段内群内成员的消息，群主/群管理员撤回自己发送的消息还是会受到message.recall_time_limit时间限制。
+##禁止群主/群管理员撤回群内消息，关闭时群主/群管理员可以撤回任意时间段内群内成员的消息。
 message.disable_group_manager_recall false

-## 禁止客户端发送消息类型，消息类型以逗号分开，下面3个值为示例，可以删除。
-## 一般用于重要类型消息，比如交易、充值等，禁止客户端发送，仅限于服务器发送，提高安全性。
+##禁止客户端发送消息类型，消息类型以逗号分开，下面3个值为示例，可以删除。
+##一般用于重要类型消息，比如交易、充值等，禁止客户端发送，仅限于服务器发送，提高安全性。
 #message.forbidden_client_send_types 3999,4000,4001

 ## 当禁止发送消息时，允许例外发送的消息。这种一般用户需要被动回应的消息。比如群中被禁言的用户，他无法主动发起音视频，但可以接听未被禁言用户的音视频
@@ -93,13 +100,18 @@ message.group_mute_exception_types 401,402,403,404,405,407,408,410,411
 ## 用户被全局禁言时允许发送的消息类型
 message.global_mute_exception_types 401,402,403,404,405,407,408,410,411

+## 消息转发功能开启时，开关是否不转发server api接口消息。
+## 当为true时，不转发server api发送的消息；当为false时，转发server api发送的消息。
+message.no_forward_admin_message false
+
+
 ##禁止搜索用户
 friend.disable_search false

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

-##禁止发送好友邀请，通过server api添加好友不受此限制
+##禁止发送好友邀请，通过server api添加好友不受此限制(force参数需要为true)
 friend.disable_friend_request false

 ##好友请求重复发送的间隔，单位是毫秒，默认是7天，0为不限制
@@ -114,7 +126,7 @@ friend.request_expiration_duration 604800000
 ##添加好友后会发送欢迎消息，比如"你们已经是好友了，可以聊天了"。这个开关控制是用旧的方式还是用新的方式。
 ##旧的方式会发送notification消息（contenttype是80），内容会根据好友接收者的语言选择对应的语言，如果双方语言不一致会导致另外一方看到的不是本地语言。
 ##新的方式会发送添加好友消息（contenttype是93）和欢迎消息（contenttype是92），需要客户端实现这两种消息。
-##如果客户端已经实现这两种消息可以打开这个开关
+##如果客户端已经实现这两种消息可以打开这个开关（客户端2020.6.30添加了此消息类型）。
 friend.new_welcome_message true

 ## 聊天室观众空闲退出时间，单位为毫秒，默认为15分钟，0为永远不退出
@@ -123,6 +135,9 @@ chatroom.participant_idle_time 900000
 ## 用户向聊天室发送消息，自动加入聊天室
 chatroom.rejoin_when_active true

+## 当一个聊天室不存在时，如果有用户加入就自动创建
+chatroom.create_when_not_exist true
+
 ## 是否允许客户端发送操作群的自定义群通知消息
 group.allow_client_custom_operation_notification true

@@ -135,6 +150,24 @@ group.visible_quit_or_kickoff_notification 0
 ## 注意，修改本配置不会对已经同步的信息产生影响。
 #user.hide_properties 3,4,5

+# 好友/好友请求/用户设置 这三类数据同步的最大条目数。之前是客户第一次登录时，会把所有的对应数据一次下载到客户端，但如果有特别多的信息，会导致无法同步到客户端，
+# 因此需要分段多次同步，此开关定义了每次同步的数据的条数。此需要客户端支持，客户端SDK在2021.5.25日后支持此功能。如果确认所有客户端都在这个日志之后才可以打开此设置。
+#sync.data_part_size 1000
+
+#*********************************************************************
+# 限频配置
+#*********************************************************************
+##API接口限频设置，时间是10秒内允许的请求次数。
+##管理api频率限制，默认是10秒10000次。
+http.admin.rate_limit 10000
+##机器人api频率限制，默认是10秒1000次，按照机器人ID区分。
+http.robot.rate_limit 1000
+##频道api频率限制，默认是10秒1000次，按照频道ID区分。
+http.channel.rate_limit 1000
+
+##客户端请求频率限制，默认是5秒100次。通常情况下不要修改这个值。
+client.request_rate_limit 100
+
 #*********************************************************************
 # hazelcase configuration
 #*********************************************************************
@@ -144,7 +177,8 @@ hazelcast.configuration config/hazelcast.xml
 # Media server configuration
 #*********************************************************************
 ##是否使用七牛云存储。1使用七牛；0使用内存文件服务器。默认的七牛账户信息不可用，请在七牛官网申请账户并配置
-## https://docs.wildfirechat.cn/server/media_server.html
+##专业版另外支持阿里云存储和野火私有存储，关于野火私有存储请参考：https://github.com/wildfirechat/WF-minio
+##关于对象存储的详细信息请参考：https://docs.wildfirechat.cn/server/oss.html
 media.server.use_qiniu 0

 ##媒体类型分类
@@ -183,12 +217,27 @@ qiniu.bucket_favorite_domain http://cdn2.wildfirechat.cn
 # local media server configuration
 # 本地媒体服务器配置。
 local.media.storage.root media
+# 如果使用内置文件存储，文件上传后地址默认为 http://server.ip:http_port/fs/5/2021/03/27/08/filename。
+# 如果需要使用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
+# local.media.storage.remote_server_url https://example.com/media

-# 是否支持多端登陆，为true时支持任意平台任意多个客户端同时登录；为false时每个平台只支持一个端登录，但不同平台可以同时登录。
+# 是否支持任意多端登陆，为true时支持任意平台任意多个客户端同时登录；为false时每个平台只支持一个端登录，但不同平台可以同时登录。
+# Android/iOS为移动平台，windows/mac/linux为pc平台，web为web平台，小程序为小程序平台。
+# 建议使用false
 server.multi_endpoint false

 # 多平台连接状态通知（仅当multi_endpoint为false时有效），true时移动端可以收到pc或web端登录的通知。
-server.multi_platform_notification false
+server.multi_platform_notification true
+
+# 当pc或者web在线时，手机是否默认静音，默认为true。注意仅影响默认值，用户可以手动切换是否静音。
+# 如果这里改为false，客户端那边需要同步修改pc在线默认通知状态，方法是client的setDefaultSilentWhenPcOnline函数。
+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

 #*********************************************************************
 # Push server configuration
@@ -205,6 +254,8 @@ push.ios.server.address http://localhost:8085/ios/push
 #*********************************************************************
 # 监控配置
 #*********************************************************************
+##异常事件产生回调
+##注意回调是单线程回调，接收服务必须在同一内网，且异步处理快速返回，否则会有延迟问题！！
 #monitor.exception_event_address http://localhost:8888/im_exception_event/

 #*********************************************************************
@@ -228,6 +279,11 @@ push.ios.server.address http://localhost:8085/ios/push
 ##需要转发的消息类型，当有多个时以英文逗号分割。如果转发所有消息，请注释掉配置或者设置为空
 #message.forward.types 1,2,3

+##提醒消息转发地址，@全体用户和@某个用户消息会回调此地址。此转发不受${message.forward.types}限制。
+##注意回调是单线程回调，接收服务必须在同一内网，且异步处理快速返回，否则会有延迟问题！！
+#message.mentionmsg.forward.url http://localhost:8888/im_event/message
+
+
 ##设备信息转发地址
 ##注意回调是单线程回调，接收服务必须在同一内网，且异步处理快速返回，否则会有延迟问题！！
 #things_message.forward.url http://localhost:8888/im_event/things/message
@@ -264,7 +320,7 @@ sensitive.filter.type 0
 #sensitive.remote_server_url http://192.168.3.202:8888/message/censor
 ## 需要进行敏感词审核的消息类型，当有多个时以英文逗号分割
 #sensitive.remote_sensitive_message_type 1,2,3
-## 如果远程审核服务返回403，返回给发送端发送失败还是成功？实际上这个值影响发送响应是否等待审核结果，当为false时，消息发送给审核服务就立即返回
-## 成功给客户端。当为true时，消息发送给审核服务，等待审核结果，如果结果为继续发送就返回给客户端为成功，结果为禁止发送就返回失败给客户端。
+## 如果远程审核服务返回403，返回给发送端发送失败还是成功？实际上这个值影响发送响应是否等待审核结果，当为false时，消息发送给审核服务就立即返回成功给客户端。
+## 当为true时，消息发送给审核服务，等待审核结果，如果结果为继续发送就返回给客户端为成功，结果为禁止发送就返回失败给客户端。
 ## 客户端操作的超时一般为10s左右，且考虑到复杂的网络情况，建议处理时间不要超过3s。建议这个值为false。
 #sensitive.remote_fail_when_matched false
@@ -5,7 +5,7 @@
        <relativePath>../</relativePath>
        <artifactId>wildfirechat-parent</artifactId>
        <groupId>cn.wildfirechat</groupId>
-        <version>0.63</version>
+        <version>0.75</version>
    </parent>

    <artifactId>moquette-broker</artifactId>
@@ -84,7 +84,7 @@
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
-            <version>4.4.1</version>
+            <version>4.5.13</version>
        </dependency>

        <dependency>
@@ -32,6 +32,7 @@ public class PushMessage {
    public String voipDeviceToken;
    public boolean isHiddenDetail;
    public String language;
+    public long messageId;

    public PushMessage(String sender, int conversationType, String target, int line, int messageContentType, long serverTime, String senderName, String targetName, int unReceivedMsg, int mentionedType, boolean isHiddenDetail, String language) {
        this.sender = sender;
@@ -49,6 +50,10 @@ public class PushMessage {
            this.pushMessageType = PushServer.PushMessageType.PUSH_MESSAGE_TYPE_VOIP_BYE;
        } else if(cntType == 401) {
            this.pushMessageType = PushServer.PushMessageType.PUSH_MESSAGE_TYPE_VOIP_ANSWER;
+        } else if(cntType == 80) {
+            this.pushMessageType = PushServer.PushMessageType.PUSH_MESSAGE_TYPE_RECALLED;
+        } else if(cntType == 81) {
+            this.pushMessageType = PushServer.PushMessageType.PUSH_MESSAGE_TYPE_DELETED;
        } else {
            this.pushMessageType = PushServer.PushMessageType.PUSH_MESSAGE_TYPE_NORMAL;
        }
@@ -35,6 +35,8 @@ public class PushServer {
        int PUSH_MESSAGE_TYPE_VOIP_BYE = 2;
        int PUSH_MESSAGE_TYPE_FRIEND_REQUEST = 3;
        int PUSH_MESSAGE_TYPE_VOIP_ANSWER = 4;
+        int PUSH_MESSAGE_TYPE_RECALLED = 5;
+        int PUSH_MESSAGE_TYPE_DELETED = 6;
    }

    private static PushServer INSTANCE = new PushServer();
@@ -13,6 +13,7 @@ import com.xiaoleilu.loServer.RestResult;
 import com.xiaoleilu.loServer.annotation.RequireAuthentication;
 import com.xiaoleilu.loServer.handler.Request;
 import com.xiaoleilu.loServer.handler.Response;
+import io.moquette.server.config.IConfig;
 import io.moquette.spi.IMessagesStore;
 import io.moquette.spi.ISessionsStore;
 import io.moquette.spi.impl.Utils;
@@ -21,10 +22,12 @@ 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 win.liyufan.im.RateLimiter;

 import java.nio.charset.StandardCharsets;

 import static cn.wildfirechat.common.ErrorCode.ERROR_CODE_SUCCESS;
+import static io.moquette.BrokerConstants.*;

 /**
 * 请求处理接口<br>
@@ -38,7 +41,35 @@ abstract public class Action {
    public static ISessionsStore sessionsStore = null;

    public ChannelHandlerContext ctx;
-    public Response response;
+
+    protected static RateLimiter adminLimiter = null;
+    protected static RateLimiter robotLimiter = null;
+    protected static RateLimiter channelLimiter = null;
+
+    public static void init(IConfig config) {
+        int adminRate = 10000;
+        int robotRate = 1000;
+        int channelRate = 1000;
+
+        try {
+            adminRate = Integer.parseInt(config.getProperty(HTTP_ADMIN_RATE_LIMIT, "10000"));
+        } catch (NumberFormatException e) {
+
+        }
+        try {
+            robotRate = Integer.parseInt(config.getProperty(HTTP_ROBOT_RATE_LIMIT, "1000"));
+        } catch (NumberFormatException e) {
+
+        }
+        try {
+            channelRate = Integer.parseInt(config.getProperty(HTTP_CHANNEL_RATE_LIMIT, "1000"));
+        } catch (NumberFormatException e) {
+
+        }
+        adminLimiter = new RateLimiter(10, adminRate);
+        robotLimiter = new RateLimiter(10, robotRate);
+        channelLimiter = new RateLimiter(10, channelRate);
+    }

    protected class Result {
        Object data;
@@ -73,7 +104,7 @@ abstract public class Action {

        return ERROR_CODE_SUCCESS;
    }
-	public boolean doAction(Request request) {
+	public boolean doAction(Request request, Response response) {
        ErrorCode errorCode = preAction(request, response);
        boolean isSync = true;
        if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
@@ -89,7 +120,7 @@ abstract public class Action {
 //                    throw e;
 //                }
 //            } else {
-            isSync = action(request);
+            isSync = action(request, response);
 //            }
        } else {
            response.setStatus(HttpResponseStatus.OK);
@@ -107,7 +138,7 @@ abstract public class Action {
    public boolean isTransactionAction() {
        return false;
    }
-    abstract public boolean action(Request request);
+    abstract public boolean action(Request request, Response response);

    protected <T> T getRequestBody(HttpRequest request, Class<T> cls) {
        if (request instanceof FullHttpRequest) {
@@ -121,7 +152,7 @@ abstract public class Action {
        return null;
    }

-    protected void setResponseContent(RestResult result) {
+    protected void setResponseContent(RestResult result, Response response) {
        response.setStatus(HttpResponseStatus.OK);
        response.setContent(new Gson().toJson(result));
    }
@@ -29,7 +29,7 @@ import java.io.IOException;
 public class CheckTokenAction extends Action {
    private final RateLimiter mLimitCounter = new RateLimiter(10, 1);
    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            response.setStatus(HttpResponseStatus.OK);
            String userId = request.getParam("userId");
@@ -12,7 +12,7 @@ import io.moquette.spi.IMessagesStore;
 */
 public class DefaultIndexAction extends Action{
    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        response.setContent("Welcome to LoServer.");
        return true;
    }
@@ -34,7 +34,7 @@ public class FileAction extends Action {
    private static final org.slf4j.Logger Logger = LoggerFactory.getLogger(FileAction.class);

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        response.setHeader("Access-Control-Allow-Origin", "*");
        if (false == Request.METHOD_GET.equalsIgnoreCase(request.getMethod())) {
            response.sendError(HttpResponseStatus.METHOD_NOT_ALLOWED, "Please use GET method to request file!");
@@ -46,21 +46,28 @@ public class FileAction extends Action {
            return true;
        }

-        final File file = getFileByPath(request.getPath());
-        Logger.debug("Client [{}] get file [{}]", request.getIp(), file.getPath());
+        File file = null;
+        try {
+            file = getFileByPath(request.getPath());
+        } catch (Exception e) {
+            response.sendError(HttpResponseStatus.NOT_FOUND, "404 File not found!");
+            return true;
+        }

-        // 隐藏文件，跳过
-        if (file.isHidden() || !file.exists()) {
+        // 隐藏文件或不存在，跳过
+        if (file == null || file.isHidden() || !file.exists()) {
            response.sendError(HttpResponseStatus.NOT_FOUND, "404 File not found!");
            return true;
        }

        // 非文件，跳过
-        if (false == file.isFile()) {
+        if (!file.isFile()) {
            response.sendError(HttpResponseStatus.FORBIDDEN, "403 Forbidden!");
            return true;
        }

+        Logger.debug("Client [{}] get file [{}]", request.getIp(), file.getPath());
+        
        // Cache Validation
        String ifModifiedSince = request.getHeader(HttpHeaderNames.IF_MODIFIED_SINCE.toString());
        if (StrUtil.isNotBlank(ifModifiedSince)) {
@@ -34,7 +34,7 @@ import java.util.concurrent.Executor;
 public class IMAction extends Action {

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {

            FullHttpRequest fullHttpRequest = (FullHttpRequest)request.getNettyRequest();
@@ -27,7 +27,7 @@ public class NotFoundAction extends Action{
 	private final static String TEMPLATE_ERROR = "<!DOCTYPE html><html><head><title>LoServer - Error report</title><style>h1,h3 {color:white; background-color: gray;}</style></head><body><h1>HTTP Status {} - {}</h1><hr size=\"1\" noshade=\"noshade\" /><p>{}</p><hr size=\"1\" noshade=\"noshade\" /><h3>LoServer</h3></body></html>";

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        response.sendError(HttpResponseStatus.NOT_FOUND, "404 Not found!");
        return true;
    }
@@ -36,7 +36,7 @@ public class RouteAction extends Action {
    private static final Logger LOG = LoggerFactory.getLogger(RouteAction.class);

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {

            response.setContentType("application/octet-stream");
@@ -27,7 +27,7 @@ public class UnknownErrorAction extends Action{
 	private final static String TEMPLATE_ERROR = "<!DOCTYPE html><html><head><title>LoServer - Error report</title><style>h1,h3 {color:white; background-color: gray;}</style></head><body><h1>HTTP Status {} - {}</h1><hr size=\"1\" noshade=\"noshade\" /><p>{}</p><hr size=\"1\" noshade=\"noshade\" /><h3>LoServer</h3></body></html>";

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        response.setStatus(HttpResponseStatus.INTERNAL_SERVER_ERROR);
        return true;
    }
@@ -73,7 +73,7 @@ public class UploadFileAction extends Action {
    }

    @Override
-    public boolean action(Request r) {
+    public boolean action(Request r, Response response) {
        if (r.getNettyRequest() instanceof FullHttpRequest) {

            FullHttpRequest request = (FullHttpRequest) r.getNettyRequest();
@@ -28,7 +28,7 @@ public class VersionAction extends Action {


    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            response.setStatus(HttpResponseStatus.OK);

@@ -16,6 +16,7 @@ import com.hazelcast.util.StringUtil;
 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;
@@ -31,7 +32,7 @@ public class AddFriendRequestAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputAddFriendRequest input = getRequestBody(request.getNettyRequest(), InputAddFriendRequest.class);

@@ -41,7 +42,7 @@ public class AddFriendRequestAction extends AdminAction {
            }

            WFCMessage.AddFriendRequest addFriendRequest = WFCMessage.AddFriendRequest.newBuilder().setReason(input.getReason()).setTargetUid(input.getFriendUid()).build();
-            sendApiMessage(input.getUserId(), IMTopic.AddFriendRequestTopic, addFriendRequest.toByteArray(), result -> {
+            sendApiMessage(response, input.getUserId(), IMTopic.AddFriendRequestTopic, addFriendRequest.toByteArray(), result -> {
                ByteBuf byteBuf = Unpooled.buffer();
                byteBuf.writeBytes(result);
                ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
@@ -16,6 +16,7 @@ import com.xiaoleilu.loServer.annotation.HttpMethod;
 import com.xiaoleilu.loServer.annotation.Route;
 import com.xiaoleilu.loServer.handler.Request;
 import cn.wildfirechat.pojos.InputAddGroupMember;
+import com.xiaoleilu.loServer.handler.Response;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.handler.codec.http.FullHttpRequest;
@@ -33,11 +34,11 @@ public class AddGroupMemberAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputAddGroupMember inputAddGroupMember = getRequestBody(request.getNettyRequest(), InputAddGroupMember.class);
            if (inputAddGroupMember.isValide()) {
-                sendApiMessage(inputAddGroupMember.getOperator(), IMTopic.AddGroupMemberTopic, inputAddGroupMember.toProtoGroupRequest().toByteArray(), result -> {
+                sendApiMessage(response, inputAddGroupMember.getOperator(), IMTopic.AddGroupMemberTopic, inputAddGroupMember.toProtoGroupRequest().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
@@ -45,7 +46,7 @@ public class AddGroupMemberAction extends AdminAction {
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -8,6 +8,7 @@

 package com.xiaoleilu.loServer.action.admin;

+import cn.wildfirechat.common.APIPath;
 import com.google.gson.Gson;
 import com.xiaoleilu.loServer.RestResult;
 import com.xiaoleilu.loServer.action.Action;
@@ -28,7 +29,6 @@ abstract public class AdminAction extends Action {
    private static final org.slf4j.Logger LOG = LoggerFactory.getLogger(AdminAction.class);
    private static String SECRET_KEY = "123456";
    private static boolean NO_CHECK_TIME = false;
-    private final RateLimiter mLimitCounter = new RateLimiter(10, 500);
    public static void setSecretKey(String secretKey) {
        SECRET_KEY = secretKey;
    }
@@ -43,10 +43,14 @@ abstract public class AdminAction extends Action {

    @Override
    public ErrorCode preAction(Request request, Response response) {
-        if (!mLimitCounter.isGranted("admin")) {
+        if (!adminLimiter.isGranted("admin")) {
            return ErrorCode.ERROR_CODE_OVER_FREQUENCY;
        }
-        
+
+        if(APIPath.Health.equals(request.getUri())) {
+            return ErrorCode.ERROR_CODE_SUCCESS;
+        }
+
        String nonce = request.getHeader("nonce");
        if (StringUtil.isNullOrEmpty(nonce)) {
            nonce = request.getHeader("Nonce");
@@ -83,24 +87,26 @@ abstract public class AdminAction extends Action {
    }

    protected void sendResponse(Response response, ErrorCode errorCode, Object data) {
-        response.setStatus(HttpResponseStatus.OK);
-        if (errorCode == null) {
-            errorCode = ErrorCode.ERROR_CODE_SUCCESS;
+        if(response != null) {
+            response.setStatus(HttpResponseStatus.OK);
+            if (errorCode == null) {
+                errorCode = ErrorCode.ERROR_CODE_SUCCESS;
+            }
+
+            RestResult result = RestResult.resultOf(errorCode, errorCode.getMsg(), data);
+            response.setContent(new Gson().toJson(result));
+            response.send();
        }
-
-        RestResult result = RestResult.resultOf(errorCode, errorCode.getMsg(), data);
-        response.setContent(new Gson().toJson(result));
-        response.send();
    }
-    protected void sendApiMessage(String fromUser, String topic, byte[] message, ApiCallback callback) {
-        sendApiMessage(fromUser, null, topic, message, callback, false);
+    protected void sendApiMessage(Response response, String fromUser, String topic, byte[] message, ApiCallback callback) {
+        sendApiMessage(response, fromUser, null, topic, message, callback, false);
    }

-    protected void sendApiMessage(String fromUser, String topic, byte[] message, ApiCallback callback, boolean noAdmin) {
-        sendApiMessage(fromUser, null, topic, message, callback, noAdmin);
+    protected void sendApiMessage(Response response, String fromUser, String topic, byte[] message, ApiCallback callback, boolean noAdmin) {
+        sendApiMessage(response, fromUser, null, topic, message, callback, noAdmin);
    }

-    protected void sendApiMessage(String fromUser, String clientId, String topic, byte[] message, ApiCallback callback, boolean noAdmin) {
+    protected void sendApiMessage(Response response, String fromUser, String clientId, String topic, byte[] message, ApiCallback callback, boolean noAdmin) {
        ServerAPIHelper.sendRequest(fromUser, clientId, topic, message, new ServerAPIHelper.Callback() {
            @Override
            public void onSuccess(byte[] result) {
@@ -37,7 +37,7 @@ public class AliasGetAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputGetAlias input = getRequestBody(request.getNettyRequest(), InputGetAlias.class);
            List<FriendData> dataList = messagesStore.getFriendList(input.getOperator(), null, 0);
@@ -51,7 +51,7 @@ public class AliasGetAction extends AdminAction {
                }
            }

-            setResponseContent(RestResult.ok(out));
+            setResponseContent(RestResult.ok(out), response);
        }
        return true;
    }
@@ -12,16 +12,22 @@ import cn.wildfirechat.common.APIPath;
 import cn.wildfirechat.common.ErrorCode;
 import cn.wildfirechat.pojos.InputGetFriendList;
 import cn.wildfirechat.pojos.InputUpdateAlias;
+import cn.wildfirechat.pojos.OutputCreateChannel;
 import cn.wildfirechat.pojos.OutputStringList;
+import cn.wildfirechat.proto.WFCMessage;
 import com.google.gson.Gson;
+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 com.xiaoleilu.loServer.model.FriendData;
+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 win.liyufan.im.IMTopic;

 import java.util.ArrayList;
 import java.util.List;
@@ -36,11 +42,29 @@ public class AliasPutAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputUpdateAlias input = getRequestBody(request.getNettyRequest(), InputUpdateAlias.class);
-            ErrorCode errorCode = messagesStore.setFriendAliasRequest(input.getOperator(), input.getTargetId(), input.getAlias(), new long[1]);
-            setResponseContent(RestResult.resultOf(errorCode));
+            if(!StringUtil.isNullOrEmpty(input.getOperator()) && !StringUtil.isNullOrEmpty(input.getTargetId())) {
+                WFCMessage.AddFriendRequest addFriendRequest = WFCMessage.AddFriendRequest.newBuilder().setTargetUid(input.getTargetId()).setReason(input.getAlias()==null?"":input.getAlias()).build();
+                sendApiMessage(response, input.getOperator(), IMTopic.SetFriendAliasTopic, addFriendRequest.toByteArray(), result -> {
+                    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 false;
+            } else {
+                ErrorCode errorCode = messagesStore.setFriendAliasRequest(input.getOperator(), input.getTargetId(), input.getAlias(), new long[1]);
+                setResponseContent(RestResult.resultOf(errorCode), response);
+            }
        }
        return true;
    }
@@ -17,6 +17,7 @@ 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;
@@ -34,7 +35,7 @@ public class BlacklistAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputBlacklistRequest inputData = getRequestBody(request.getNettyRequest(), InputBlacklistRequest.class);
            if (inputData != null
@@ -42,7 +43,7 @@ public class BlacklistAction extends AdminAction {
                && !StringUtil.isNullOrEmpty(inputData.getTargetUid())
            ) {
                WFCMessage.BlackUserRequest friendRequest = WFCMessage.BlackUserRequest.newBuilder().setUid(inputData.getTargetUid()).setStatus(inputData.getStatus()).build();
-                sendApiMessage(inputData.getUserId(), IMTopic.BlackListUserTopic, friendRequest.toByteArray(), result -> {
+                sendApiMessage(response, inputData.getUserId(), IMTopic.BlackListUserTopic, friendRequest.toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
@@ -50,7 +51,7 @@ public class BlacklistAction extends AdminAction {
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -35,7 +35,7 @@ public class BlacklistGetAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputUserId inputGetFriendList = getRequestBody(request.getNettyRequest(), InputUserId.class);
            List<FriendData> dataList = messagesStore.getFriendList(inputGetFriendList.getUserId(), null, 0);
@@ -45,7 +45,7 @@ public class BlacklistGetAction extends AdminAction {
                    list.add(data.getFriendUid());
                }
            }
-            setResponseContent(RestResult.ok(new OutputStringList(list)));
+            setResponseContent(RestResult.ok(new OutputStringList(list)), response);
        }
        return true;
    }
@@ -15,6 +15,7 @@ import com.xiaoleilu.loServer.annotation.HttpMethod;
 import com.xiaoleilu.loServer.annotation.Route;
 import com.xiaoleilu.loServer.handler.Request;
 import cn.wildfirechat.pojos.InputOutputUserBlockStatus;
+import com.xiaoleilu.loServer.handler.Response;
 import io.moquette.persistence.ServerAPIHelper;
 import io.netty.handler.codec.http.FullHttpRequest;
 import io.netty.handler.codec.http.HttpResponseStatus;
@@ -31,7 +32,7 @@ public class BlockUserAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputOutputUserBlockStatus inputUserBlock = getRequestBody(request.getNettyRequest(), InputOutputUserBlockStatus.class);
            if (inputUserBlock != null
@@ -44,12 +45,12 @@ public class BlockUserAction extends AdminAction {
                response.setContent(new Gson().toJson(result));

                if (inputUserBlock.getStatus() == 2) {
-                    sendApiMessage(null, ServerAPIHelper.KICKOFF_USER_REQUEST, inputUserBlock.getUserId().getBytes(), null);
+                    sendApiMessage(null, null, ServerAPIHelper.KICKOFF_USER_REQUEST, inputUserBlock.getUserId().getBytes(), null);
                }

                sendResponse(response, ErrorCode.ERROR_CODE_SUCCESS, null);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -19,6 +19,7 @@ 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;
@@ -35,11 +36,11 @@ public class BroadcastMessageAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            BroadMessageData sendMessageData = getRequestBody(request.getNettyRequest(), BroadMessageData.class);
            if (BroadMessageData.isValide(sendMessageData) && !StringUtil.isNullOrEmpty(sendMessageData.getSender())) {
-                sendApiMessage(sendMessageData.getSender(), IMTopic.BroadcastMessageTopic, sendMessageData.toProtoMessage().toByteArray(), result -> {
+                sendApiMessage(response, sendMessageData.getSender(), IMTopic.BroadcastMessageTopic, sendMessageData.toProtoMessage().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
@@ -53,7 +54,7 @@ public class BroadcastMessageAction extends AdminAction {
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -15,6 +15,7 @@ import com.xiaoleilu.loServer.annotation.HttpMethod;
 import com.xiaoleilu.loServer.annotation.Route;
 import com.xiaoleilu.loServer.handler.Request;
 import cn.wildfirechat.pojos.InputGetUserInfo;
+import com.xiaoleilu.loServer.handler.Response;
 import io.moquette.persistence.ServerAPIHelper;
 import io.netty.handler.codec.http.FullHttpRequest;
 import io.netty.util.internal.StringUtil;
@@ -30,11 +31,11 @@ public class CheckUserOnlineAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputGetUserInfo inputUserId = getRequestBody(request.getNettyRequest(), InputGetUserInfo.class);
            if (inputUserId == null || !StringUtil.isNullOrEmpty(inputUserId.getUserId())) {
-                sendApiMessage(inputUserId.getUserId(), ServerAPIHelper.CHECK_USER_ONLINE_REQUEST, inputUserId.getUserId().getBytes(), res -> {
+                sendApiMessage(response, inputUserId.getUserId(), ServerAPIHelper.CHECK_USER_ONLINE_REQUEST, inputUserId.getUserId().getBytes(), res -> {
                    OutputCheckUserOnline out = new Gson().fromJson(new String(res), OutputCheckUserOnline.class);
                    return new Result(ErrorCode.ERROR_CODE_SUCCESS, out);
                });
@@ -16,6 +16,7 @@ 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;
@@ -33,7 +34,7 @@ public class CreateChannelAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputCreateChannel inputCreateChannel = getRequestBody(request.getNettyRequest(), InputCreateChannel.class);
            if (inputCreateChannel != null
@@ -45,7 +46,7 @@ public class CreateChannelAction extends AdminAction {
                    inputCreateChannel.setTargetId(messagesStore.getShortUUID());
                }

-                sendApiMessage(inputCreateChannel.getOwner(), IMTopic.CreateChannelTopic, inputCreateChannel.toProtoChannelInfo().toByteArray(), result -> {
+                sendApiMessage(response, inputCreateChannel.getOwner(), IMTopic.CreateChannelTopic, inputCreateChannel.toProtoChannelInfo().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
@@ -60,7 +61,7 @@ public class CreateChannelAction extends AdminAction {
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -34,7 +34,7 @@ public class CreateChatroomAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            FullHttpRequest fullHttpRequest = (FullHttpRequest)request.getNettyRequest();
            byte[] bytes = Utils.readBytesAndRewind(fullHttpRequest.content());
@@ -54,9 +54,9 @@ public class CreateChatroomAction extends AdminAction {

                WFCMessage.ChatroomInfo info = inputCreateChatroom.toChatroomInfo();
                messagesStore.createChatroom(inputCreateChatroom.getChatroomId(), info);
-                setResponseContent(RestResult.ok(new OutputCreateChatroom(inputCreateChatroom.getChatroomId())));
+                setResponseContent(RestResult.ok(new OutputCreateChatroom(inputCreateChatroom.getChatroomId())), response);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -17,6 +17,7 @@ import com.xiaoleilu.loServer.annotation.Route;
 import com.xiaoleilu.loServer.handler.Request;
 import cn.wildfirechat.pojos.InputCreateGroup;
 import cn.wildfirechat.pojos.OutputCreateGroupResult;
+import com.xiaoleilu.loServer.handler.Response;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.handler.codec.http.FullHttpRequest;
@@ -34,11 +35,11 @@ public class CreateGroupAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputCreateGroup inputCreateGroup = getRequestBody(request.getNettyRequest(), InputCreateGroup.class);
            if (inputCreateGroup.isValide()) {
-                sendApiMessage(inputCreateGroup.getOperator(), IMTopic.CreateGroupTopic, inputCreateGroup.toProtoGroupRequest().toByteArray(), result -> {
+                sendApiMessage(response, inputCreateGroup.getOperator(), IMTopic.CreateGroupTopic, inputCreateGroup.toProtoGroupRequest().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
@@ -53,7 +54,7 @@ public class CreateGroupAction extends AdminAction {
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -39,7 +39,7 @@ public class CreateRobotAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputCreateRobot inputCreateRobot = getRequestBody(request.getNettyRequest(), InputCreateRobot.class);
            if (inputCreateRobot != null
@@ -79,9 +79,9 @@ public class CreateRobotAction extends AdminAction {
                    inputCreateRobot.setSecret(UUIDGenerator.getUUID());
                }
                messagesStore.addRobot(inputCreateRobot.toRobot());
-                setResponseContent(RestResult.ok(new OutputCreateRobot(inputCreateRobot.getUserId(), inputCreateRobot.getSecret())));
+                setResponseContent(RestResult.ok(new OutputCreateRobot(inputCreateRobot.getUserId(), inputCreateRobot.getSecret())), response);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -40,7 +40,7 @@ public class CreateUserAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputOutputUserInfo inputCreateUser = getRequestBody(request.getNettyRequest(), InputOutputUserInfo.class);
            if (inputCreateUser != null
@@ -89,13 +89,13 @@ public class CreateUserAction extends AdminAction {
                } catch (Exception e) {
                    e.printStackTrace();
                    Utility.printExecption(LOG, e, IMExceptionEvent.EventType.ADMIN_API_Exception);
-                    setResponseContent(RestResult.resultOf(ErrorCode.ERROR_CODE_SERVER_ERROR, e.getMessage()));
+                    setResponseContent(RestResult.resultOf(ErrorCode.ERROR_CODE_SERVER_ERROR, e.getMessage()), response);
                    return true;
                }

-                setResponseContent(RestResult.ok(new OutputCreateUser(inputCreateUser.getUserId(), inputCreateUser.getName())));
+                setResponseContent(RestResult.ok(new OutputCreateUser(inputCreateUser.getUserId(), inputCreateUser.getName())), response);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -32,7 +32,7 @@ public class DestoryChatroomAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            FullHttpRequest fullHttpRequest = (FullHttpRequest)request.getNettyRequest();
            byte[] bytes = Utils.readBytesAndRewind(fullHttpRequest.content());
@@ -42,9 +42,9 @@ public class DestoryChatroomAction extends AdminAction {
            if (inputDestoryChatroom != null
                && !StringUtil.isNullOrEmpty(inputDestoryChatroom.getChatroomId())) {
                messagesStore.destoryChatroom(inputDestoryChatroom.getChatroomId());
-                setResponseContent(RestResult.ok());
+                setResponseContent(RestResult.ok(), response);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -17,6 +17,7 @@ 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;
@@ -34,20 +35,20 @@ public class DestroyUserAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputDestroyUser inputDestroyUser = getRequestBody(request.getNettyRequest(), InputDestroyUser.class);
            if (inputDestroyUser != null
                && !StringUtil.isNullOrEmpty(inputDestroyUser.getUserId())) {

                WFCMessage.IDBuf idBuf = WFCMessage.IDBuf.newBuilder().setId(inputDestroyUser.getUserId()).build();
-                sendApiMessage(inputDestroyUser.getUserId(), IMTopic.DestroyUserTopic, idBuf.toByteArray(), result -> {
+                sendApiMessage(response, inputDestroyUser.getUserId(), IMTopic.DestroyUserTopic, idBuf.toByteArray(), result -> {
                    ErrorCode errorCode1 = ErrorCode.fromCode(result[0]);
                    return new Result(errorCode1);
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -16,6 +16,7 @@ import com.xiaoleilu.loServer.annotation.HttpMethod;
 import com.xiaoleilu.loServer.annotation.Route;
 import com.xiaoleilu.loServer.handler.Request;
 import cn.wildfirechat.pojos.InputDismissGroup;
+import com.xiaoleilu.loServer.handler.Response;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.handler.codec.http.FullHttpRequest;
@@ -33,11 +34,11 @@ public class DismissGroupAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputDismissGroup inputDismissGroup = getRequestBody(request.getNettyRequest(), InputDismissGroup.class);
            if (inputDismissGroup.isValide()) {
-                sendApiMessage(inputDismissGroup.getOperator(), IMTopic.DismissGroupTopic, inputDismissGroup.toProtoGroupRequest().toByteArray(), result -> {
+                sendApiMessage(response, inputDismissGroup.getOperator(), IMTopic.DismissGroupTopic, inputDismissGroup.toProtoGroupRequest().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
@@ -45,7 +46,7 @@ public class DismissGroupAction extends AdminAction {
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -0,0 +1,39 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <heavyrain.lee@gmail.com>
+ *
+ * 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.InputUpdateFriendExtra;
+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;
+
+@Route(APIPath.Friend_Set_Extra)
+@HttpMethod("POST")
+public class FriendExtraPutAction extends AdminAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    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);
+        }
+        return true;
+    }
+}
@@ -16,6 +16,7 @@ import com.xiaoleilu.loServer.annotation.HttpMethod;
 import com.xiaoleilu.loServer.annotation.Route;
 import com.xiaoleilu.loServer.handler.Request;
 import cn.wildfirechat.pojos.InputUpdateFriendStatusRequest;
+import com.xiaoleilu.loServer.handler.Response;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.handler.codec.http.FullHttpRequest;
@@ -34,7 +35,7 @@ public class FriendRelationAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputUpdateFriendStatusRequest friendAdd = getRequestBody(request.getNettyRequest(), InputUpdateFriendStatusRequest.class);
            if (friendAdd != null
@@ -45,7 +46,7 @@ public class FriendRelationAction extends AdminAction {
                if (!StringUtil.isNullOrEmpty(friendAdd.getExtra())) {
                    friendRequestBuilder = friendRequestBuilder.setExtra(friendAdd.getExtra());
                }
-                sendApiMessage(friendAdd.getUserId(), IMTopic.HandleFriendRequestTopic, friendRequestBuilder.build().toByteArray(), result -> {
+                sendApiMessage(response, friendAdd.getUserId(), IMTopic.HandleFriendRequestTopic, friendRequestBuilder.build().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
@@ -53,7 +54,7 @@ public class FriendRelationAction extends AdminAction {
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -36,7 +36,7 @@ public class FriendRelationGetAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputUserId inputGetFriendList = getRequestBody(request.getNettyRequest(), InputUserId.class);
            List<FriendData> dataList = messagesStore.getFriendList(inputGetFriendList.getUserId(), null, 0);
@@ -47,7 +47,7 @@ public class FriendRelationGetAction extends AdminAction {
                    list.add(data.getFriendUid());
                }
            }
-            setResponseContent(RestResult.ok(new OutputStringList(list)));
+            setResponseContent(RestResult.ok(new OutputStringList(list)), response);
        }
        return true;
    }
@@ -32,7 +32,7 @@ public class GetChatroomInfoAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputGetChatroomInfo getChatroomInfo = getRequestBody(request.getNettyRequest(), InputGetChatroomInfo.class);
            String chatroomid = getChatroomInfo.getChatroomId();
@@ -46,9 +46,9 @@ public class GetChatroomInfoAction extends AdminAction {
                } else {
                    result = RestResult.resultOf(ErrorCode.ERROR_CODE_NOT_EXIST);
                }
-                setResponseContent(result);
+                setResponseContent(result, response);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -39,7 +39,7 @@ public class GetChatroomMembersAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputGetChatroomInfo getChatroomInfo = getRequestBody(request.getNettyRequest(), InputGetChatroomInfo.class);
            String chatroomid = getChatroomInfo.getChatroomId();
@@ -58,9 +58,9 @@ public class GetChatroomMembersAction extends AdminAction {
                } else {
                    result = RestResult.resultOf(ErrorCode.ERROR_CODE_NOT_EXIST);
                }
-                setResponseContent(result);
+                setResponseContent(result, response);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -35,7 +35,7 @@ public class GetGroupInfoAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputGetGroup inputGetGroup = getRequestBody(request.getNettyRequest(), InputGetGroup.class);
            if (inputGetGroup != null
@@ -53,11 +53,15 @@ public class GetGroupInfoAction extends AdminAction {
                    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());
                    result = RestResult.ok(pojoGroupInfo);
                }
-                setResponseContent(result);
+                setResponseContent(result, response);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -39,7 +39,7 @@ public class GetGroupMembersAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputGetGroup inputGetGroup = getRequestBody(request.getNettyRequest(), InputGetGroup.class);
            if (inputGetGroup != null
@@ -68,9 +68,9 @@ public class GetGroupMembersAction extends AdminAction {
                    result = RestResult.ok(out);
                }

-                setResponseContent(result);
+                setResponseContent(result, response);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -15,8 +15,11 @@ import com.xiaoleilu.loServer.annotation.Route;
 import com.xiaoleilu.loServer.handler.Request;
 import cn.wildfirechat.pojos.InputGetToken;
 import cn.wildfirechat.pojos.OutputGetIMTokenData;
+import com.xiaoleilu.loServer.handler.Response;
 import io.netty.handler.codec.http.FullHttpRequest;
 import cn.wildfirechat.common.ErrorCode;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import win.liyufan.im.IMTopic;

 import java.util.Base64;
@@ -24,21 +27,21 @@ import java.util.Base64;
@Route(APIPath.User_Get_Token)
@HttpMethod("POST")
 public class GetIMTokenAction extends AdminAction {
-
+    private static final Logger LOG = LoggerFactory.getLogger(GetIMTokenAction.class);
    @Override
    public boolean isTransactionAction() {
        return false;
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputGetToken input = getRequestBody(request.getNettyRequest(), InputGetToken.class);
            String userId = input.getUserId();


            WFCMessage.GetTokenRequest getTokenRequest = WFCMessage.GetTokenRequest.newBuilder().setUserId(userId).setClientId(input.getClientId()).setPlatform(input.getPlatform() == null ? 0 : input.getPlatform()).build();
-            sendApiMessage(userId, input.getClientId(), IMTopic.GetTokenTopic, getTokenRequest.toByteArray(), result -> {
+            sendApiMessage(response, userId, input.getClientId(), IMTopic.GetTokenTopic, getTokenRequest.toByteArray(), result -> {
                ErrorCode errorCode1 = ErrorCode.fromCode(result[0]);
                if (errorCode1 == ErrorCode.ERROR_CODE_SUCCESS) {
                    //ba errorcode qudiao
@@ -48,6 +51,8 @@ public class GetIMTokenAction extends AdminAction {
                    }
                    String token = Base64.getEncoder().encodeToString(data);

+                    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));
                } else {
                    return new Result(errorCode1);
@@ -34,7 +34,7 @@ public class GetSystemSettingAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            SystemSettingPojo inputUserId = getRequestBody(request.getNettyRequest(), SystemSettingPojo.class);
            if (inputUserId != null) {
@@ -47,9 +47,9 @@ public class GetSystemSettingAction extends AdminAction {
                    result = RestResult.ok(output);
                }

-                setResponseContent(result);
+                setResponseContent(result, response);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -33,7 +33,7 @@ public class GetUserAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputGetUserInfo inputUserId = getRequestBody(request.getNettyRequest(), InputGetUserInfo.class);
            if (inputUserId != null
@@ -55,9 +55,9 @@ public class GetUserAction extends AdminAction {
                    result = RestResult.ok(InputOutputUserInfo.fromPbUser(user));
                }

-                setResponseContent(result);
+                setResponseContent(result, response);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -29,12 +29,12 @@ public class GetUserBlockListAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            OutputUserBlockStatusList list = new OutputUserBlockStatusList();
            list.setStatusList(messagesStore.getUserStatusList());
            RestResult result = RestResult.ok(list);
-            setResponseContent(result);
+            setResponseContent(result, response);
        }
        return true;
    }
@@ -32,16 +32,16 @@ public class GetUserBlockStatusAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputGetUserInfo inputUserId = getRequestBody(request.getNettyRequest(), InputGetUserInfo.class);
            if (inputUserId != null
                && !StringUtil.isNullOrEmpty(inputUserId.getUserId())) {

                int status = messagesStore.getUserStatus(inputUserId.getUserId());
-                setResponseContent(RestResult.ok(new OutputUserStatus(status)));
+                setResponseContent(RestResult.ok(new OutputUserStatus(status)), response);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -38,7 +38,7 @@ public class GetUserGroupsAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputUserId inputUserId = getRequestBody(request.getNettyRequest(), InputUserId.class);
            if (inputUserId != null
@@ -48,9 +48,9 @@ public class GetUserGroupsAction extends AdminAction {
                OutputGroupIds outputGroupIds = new OutputGroupIds();
                outputGroupIds.setGroupIds(new ArrayList<>(groupIds));
                RestResult result = RestResult.ok(outputGroupIds);
-                setResponseContent(result);
+                setResponseContent(result, response);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -0,0 +1,73 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <heavyrain.lee@gmail.com>
+ *
+ * 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.pojos.OutputUserBlockStatusList;
+import com.xiaoleilu.loServer.RestResult;
+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 org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+
+import java.io.File;
+import java.lang.management.OperatingSystemMXBean;
+
+import static java.lang.management.ManagementFactory.getOperatingSystemMXBean;
+
+@Route(APIPath.Health)
+public class HealthAction extends AdminAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            JSONObject jsonObject = new JSONObject();
+
+            jsonObject.put("node", "1");
+
+            JSONObject cpuObject = new JSONObject();
+            jsonObject.put("cpu", cpuObject);
+
+            JSONObject memoryObject = new JSONObject();
+            jsonObject.put("memory", memoryObject);
+
+            JSONObject fileObject = new JSONObject();
+            jsonObject.put("disk", fileObject);
+
+            if (getOperatingSystemMXBean() instanceof OperatingSystemMXBean) {
+                double load = getOperatingSystemMXBean().getSystemLoadAverage();
+                cpuObject.put("load", load);
+            }
+            cpuObject.put("cores", Runtime.getRuntime().availableProcessors());
+
+            memoryObject.put("free", Runtime.getRuntime().freeMemory());
+            memoryObject.put("max", Runtime.getRuntime().maxMemory());
+            memoryObject.put("avail", Runtime.getRuntime().totalMemory());
+
+            File root = new File("/");
+            fileObject.put("space", root.getTotalSpace());
+            fileObject.put("free", root.getFreeSpace());
+            fileObject.put("usable", root.getUsableSpace());
+
+            JSONArray out = new JSONArray();
+            out.add(jsonObject);
+            RestResult result = RestResult.ok(out);
+            setResponseContent(result, response);
+        }
+        return true;
+    }
+}
@@ -16,6 +16,7 @@ import com.xiaoleilu.loServer.annotation.HttpMethod;
 import com.xiaoleilu.loServer.annotation.Route;
 import com.xiaoleilu.loServer.handler.Request;
 import cn.wildfirechat.pojos.InputKickoffGroupMember;
+import com.xiaoleilu.loServer.handler.Response;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.handler.codec.http.FullHttpRequest;
@@ -33,11 +34,11 @@ public class KickoffGroupMemberAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputKickoffGroupMember inputKickoffGroupMember = getRequestBody(request.getNettyRequest(), InputKickoffGroupMember.class);
            if (inputKickoffGroupMember.isValide()) {
-                sendApiMessage(inputKickoffGroupMember.getOperator(), IMTopic.KickoffGroupMemberTopic, inputKickoffGroupMember.toProtoGroupRequest().toByteArray(), result -> {
+                sendApiMessage(response, inputKickoffGroupMember.getOperator(), IMTopic.KickoffGroupMemberTopic, inputKickoffGroupMember.toProtoGroupRequest().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
@@ -45,7 +46,7 @@ public class KickoffGroupMemberAction extends AdminAction {
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -31,14 +31,14 @@ public class KickoffUserClientAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            StringPairPojo pojo = getRequestBody(request.getNettyRequest(), StringPairPojo.class);
            if (pojo != null && !StringUtil.isNullOrEmpty(pojo.getFirst())) {
                sessionsStore.kickoffUserClient(pojo.getFirst(), pojo.getSecond());
                sendResponse(response, ErrorCode.ERROR_CODE_SUCCESS, null);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -17,6 +17,7 @@ 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;
@@ -33,11 +34,11 @@ public class ModifyGroupInfoAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputModifyGroupInfo inputAddGroupMember = getRequestBody(request.getNettyRequest(), InputModifyGroupInfo.class);
            if (inputAddGroupMember.isValide()) {
-                sendApiMessage(inputAddGroupMember.getOperator(), IMTopic.ModifyGroupInfoTopic, inputAddGroupMember.toProtoGroupRequest().toByteArray(), result -> {
+                sendApiMessage(response, inputAddGroupMember.getOperator(), IMTopic.ModifyGroupInfoTopic, inputAddGroupMember.toProtoGroupRequest().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
@@ -45,7 +46,7 @@ public class ModifyGroupInfoAction extends AdminAction {
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -17,6 +17,7 @@ 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;
@@ -33,11 +34,11 @@ public class ModifyGroupMemberAliasAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputSetGroupMemberAlias inputSetGroupMemberAlias = getRequestBody(request.getNettyRequest(), InputSetGroupMemberAlias.class);
            if (inputSetGroupMemberAlias.isValide()) {
-                sendApiMessage(inputSetGroupMemberAlias.getOperator(), IMTopic.ModifyGroupMemberAliasTopic, inputSetGroupMemberAlias.toProtoGroupRequest().toByteArray(), result -> {
+                sendApiMessage(response, inputSetGroupMemberAlias.getOperator(), IMTopic.ModifyGroupMemberAliasTopic, inputSetGroupMemberAlias.toProtoGroupRequest().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
@@ -45,7 +46,7 @@ public class ModifyGroupMemberAliasAction extends AdminAction {
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -0,0 +1,58 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <heavyrain.lee@gmail.com>
+ *
+ * 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.InputSetGroupMemberExtra;
+import com.google.gson.Gson;
+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 win.liyufan.im.IMTopic;
+
+import java.util.concurrent.Executor;
+
+@Route(APIPath.Group_Set_Member_Extra)
+@HttpMethod("POST")
+public class ModifyGroupMemberExtraAction extends AdminAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            InputSetGroupMemberExtra inputSetGroupMemberExtra = getRequestBody(request.getNettyRequest(), InputSetGroupMemberExtra.class);
+            if (inputSetGroupMemberExtra.isValide()) {
+                sendApiMessage(response, inputSetGroupMemberExtra.getOperator(), IMTopic.ModifyGroupMemberExtraTopic, inputSetGroupMemberExtra.toProtoGroupRequest().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(new Gson().toJson(result));
+            }
+        }
+        return true;
+    }
+}
@@ -18,6 +18,7 @@ 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;
@@ -34,11 +35,11 @@ public class MulticastMessageAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            MulticastMessageData sendMessageData = getRequestBody(request.getNettyRequest(), MulticastMessageData.class);
            if (MulticastMessageData.isValide(sendMessageData)) {
-                sendApiMessage(sendMessageData.getSender(), IMTopic.MultiCastMessageTopic, sendMessageData.toProtoMessage().toByteArray(), result -> {
+                sendApiMessage(response, sendMessageData.getSender(), IMTopic.MultiCastMessageTopic, sendMessageData.toProtoMessage().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
@@ -52,7 +53,7 @@ public class MulticastMessageAction extends AdminAction {
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -34,7 +34,7 @@ public class PutSystemSettingAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            SystemSettingPojo inputUserId = getRequestBody(request.getNettyRequest(), SystemSettingPojo.class);
            if (inputUserId != null
@@ -47,9 +47,9 @@ public class PutSystemSettingAction extends AdminAction {
                } else {
                    result = RestResult.ok();
                }
-                setResponseContent(result);
+                setResponseContent(result, response);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -17,6 +17,7 @@ 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;
@@ -33,11 +34,11 @@ public class QuitGroupMemberAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputQuitGroup inputQuitGroup = getRequestBody(request.getNettyRequest(), InputQuitGroup.class);
            if (inputQuitGroup.isValide()) {
-                sendApiMessage(inputQuitGroup.getOperator(), IMTopic.QuitGroupTopic, inputQuitGroup.toProtoGroupRequest().toByteArray(), result -> {
+                sendApiMessage(response, inputQuitGroup.getOperator(), IMTopic.QuitGroupTopic, inputQuitGroup.toProtoGroupRequest().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
@@ -45,7 +46,7 @@ public class QuitGroupMemberAction extends AdminAction {
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -16,6 +16,7 @@ import com.xiaoleilu.loServer.annotation.HttpMethod;
 import com.xiaoleilu.loServer.annotation.Route;
 import com.xiaoleilu.loServer.handler.Request;
 import cn.wildfirechat.pojos.RecallMessageData;
+import com.xiaoleilu.loServer.handler.Response;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.handler.codec.http.FullHttpRequest;
@@ -34,13 +35,13 @@ public class RecallMessageAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            RecallMessageData recallMessageData = getRequestBody(request.getNettyRequest(), RecallMessageData.class);
            if (recallMessageData != null && !StringUtil.isNullOrEmpty(recallMessageData.getOperator())) {

                WFCMessage.INT64Buf idBuf = WFCMessage.INT64Buf.newBuilder().setId(recallMessageData.getMessageUid()).build();
-                sendApiMessage(recallMessageData.getOperator(), IMTopic.RecallMessageTopic, idBuf.toByteArray(), result -> {
+                sendApiMessage(response, recallMessageData.getOperator(), IMTopic.RecallMessageTopic, idBuf.toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
@@ -48,7 +49,7 @@ public class RecallMessageAction extends AdminAction {
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -17,6 +17,7 @@ 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;
@@ -34,13 +35,13 @@ public class RecallMultiCastMessageAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            RecallMultiCastMessageData recallMessageData = getRequestBody(request.getNettyRequest(), RecallMultiCastMessageData.class);
            if (recallMessageData != null && !StringUtil.isNullOrEmpty(recallMessageData.operator)) {

                WFCMessage.RecallMultiCastMessageRequest recallRequest = WFCMessage.RecallMultiCastMessageRequest.newBuilder().setMessageId(recallMessageData.messageUid).addAllReceiver(recallMessageData.receivers).build();
-                sendApiMessage(recallMessageData.operator, IMTopic.RecallMultiCastMessageTopic, recallRequest.toByteArray(), result -> {
+                sendApiMessage(response, recallMessageData.operator, IMTopic.RecallMultiCastMessageTopic, recallRequest.toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
@@ -48,7 +49,7 @@ public class RecallMultiCastMessageAction extends AdminAction {
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -37,7 +37,7 @@ public class RelationGetAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            StringPairPojo input = getRequestBody(request.getNettyRequest(), StringPairPojo.class);
            FriendData data = messagesStore.getFriendData(input.getFirst(), input.getSecond());
@@ -51,7 +51,7 @@ public class RelationGetAction extends AdminAction {
                out.alias = data.getAlias();
                out.extra = data.getExtra();
            }
-            setResponseContent(RestResult.ok(out));
+            setResponseContent(RestResult.ok(out), response);
        }
        return true;
    }
@@ -18,6 +18,7 @@ import com.xiaoleilu.loServer.annotation.Route;
 import com.xiaoleilu.loServer.handler.Request;
 import cn.wildfirechat.pojos.SendMessageData;
 import cn.wildfirechat.pojos.SendMessageResult;
+import com.xiaoleilu.loServer.handler.Response;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.handler.codec.http.FullHttpRequest;
@@ -35,11 +36,11 @@ public class SendMessageAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            SendMessageData sendMessageData = getRequestBody(request.getNettyRequest(), SendMessageData.class);
            if (SendMessageData.isValide(sendMessageData) && !StringUtil.isNullOrEmpty(sendMessageData.getSender())) {
-                sendApiMessage(sendMessageData.getSender(), IMTopic.SendMessageTopic, sendMessageData.toProtoMessage().toByteArray(), result -> {
+                sendApiMessage(response, sendMessageData.getSender(), IMTopic.SendMessageTopic, sendMessageData.toProtoMessage().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
@@ -53,7 +54,7 @@ public class SendMessageAction extends AdminAction {
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -30,7 +30,7 @@ public class SensitiveWordAddAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputOutputSensitiveWords input = getRequestBody(request.getNettyRequest(), InputOutputSensitiveWords.class);
            if (input != null && input.getWords() != null && !input.getWords().isEmpty()) {
@@ -38,7 +38,7 @@ public class SensitiveWordAddAction extends AdminAction {
                response.setStatus(HttpResponseStatus.OK);
                sendResponse(response, errorCode, null);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -30,7 +30,7 @@ public class SensitiveWordDeleteAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputOutputSensitiveWords input = getRequestBody(request.getNettyRequest(), InputOutputSensitiveWords.class);
            if (input != null && input.getWords() != null && !input.getWords().isEmpty()) {
@@ -39,7 +39,7 @@ public class SensitiveWordDeleteAction extends AdminAction {

                sendResponse(response, errorCode, null);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -29,7 +29,7 @@ public class SensitiveWordQueryAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
                List<String> words = messagesStore.getAllSensitiveWords();
                InputOutputSensitiveWords out = new InputOutputSensitiveWords();
@@ -17,6 +17,7 @@ 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;
@@ -33,11 +34,11 @@ public class SetGroupManagerAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputSetGroupManager inputAddGroupMember = getRequestBody(request.getNettyRequest(), InputSetGroupManager.class);
            if (inputAddGroupMember.isValide()) {
-                sendApiMessage(inputAddGroupMember.getOperator(), IMTopic.SetGroupManagerTopic, inputAddGroupMember.toProtoGroupRequest().toByteArray(), result -> {
+                sendApiMessage(response, inputAddGroupMember.getOperator(), IMTopic.SetGroupManagerTopic, inputAddGroupMember.toProtoGroupRequest().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
@@ -45,7 +46,7 @@ public class SetGroupManagerAction extends AdminAction {
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -16,6 +16,7 @@ import com.xiaoleilu.loServer.annotation.HttpMethod;
 import com.xiaoleilu.loServer.annotation.Route;
 import com.xiaoleilu.loServer.handler.Request;
 import cn.wildfirechat.pojos.InputTransferGroup;
+import com.xiaoleilu.loServer.handler.Response;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.handler.codec.http.FullHttpRequest;
@@ -33,11 +34,11 @@ public class TransferGroupAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputTransferGroup inputDismissGroup = getRequestBody(request.getNettyRequest(), InputTransferGroup.class);
            if (inputDismissGroup.isValide()) {
-                sendApiMessage(inputDismissGroup.getOperator(), IMTopic.TransferGroupTopic, inputDismissGroup.toProtoGroupRequest().toByteArray(), result -> {
+                sendApiMessage(response, inputDismissGroup.getOperator(), IMTopic.TransferGroupTopic, inputDismissGroup.toProtoGroupRequest().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
@@ -45,7 +46,7 @@ public class TransferGroupAction extends AdminAction {
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -41,7 +41,7 @@ public class UpdateUserAction extends AdminAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputUpdateUserInfo inputCreateUser = getRequestBody(request.getNettyRequest(), InputUpdateUserInfo.class);
            if (inputCreateUser != null
@@ -50,9 +50,9 @@ public class UpdateUserAction extends AdminAction {
                && inputCreateUser.flag > 0) {

                ErrorCode errorCode = messagesStore.updateUserInfo(inputCreateUser.userInfo, inputCreateUser.flag);
-                setResponseContent(RestResult.resultOf(errorCode));
+                setResponseContent(RestResult.resultOf(errorCode), response);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -31,7 +31,6 @@ import java.util.concurrent.Executor;

 abstract public class ChannelAction extends Action {
    private static final org.slf4j.Logger LOG = LoggerFactory.getLogger(ChannelAction.class);
-    private final RateLimiter mLimitCounter = new RateLimiter(10, 200);
    protected WFCMessage.ChannelInfo channelInfo;

    protected interface Callback {
@@ -61,7 +60,7 @@ abstract public class ChannelAction extends Action {
            return ErrorCode.ERROR_CODE_API_NOT_SIGNED;
        }

-        if (!mLimitCounter.isGranted(cid)) {
+        if (!channelLimiter.isGranted(cid)) {
            return ErrorCode.ERROR_CODE_OVER_FREQUENCY;
        }

@@ -92,7 +91,7 @@ abstract public class ChannelAction extends Action {
        return localSign.equals(sign) ? ErrorCode.ERROR_CODE_SUCCESS : ErrorCode.ERROR_CODE_AUTH_FAILURE;
    }

-    protected void sendResponse(ErrorCode errorCode, Object data) {
+    protected void sendResponse(Response response, ErrorCode errorCode, Object data) {
        response.setStatus(HttpResponseStatus.OK);
        if (errorCode == null) {
            errorCode = ErrorCode.ERROR_CODE_SUCCESS;
@@ -115,10 +114,10 @@ abstract public class ChannelAction extends Action {
        return null;
    }

-    protected void sendApiMessage(String topic, byte[] message, Callback callback) {
-        sendApiMessage(channelInfo.getOwner(), topic, message, callback);
+    protected void sendApiMessage(Response response, String topic, byte[] message, Callback callback) {
+        sendApiMessage(response, channelInfo.getOwner(), topic, message, callback);
    }
-    protected void sendApiMessage(String user, String topic, byte[] message, Callback callback) {
+    protected void sendApiMessage(Response response, String user, String topic, byte[] message, Callback callback) {
        ServerAPIHelper.sendRequest(user, null, topic, message, new ServerAPIHelper.Callback() {
            @Override
            public void onSuccess(byte[] response) {
@@ -126,12 +125,12 @@ abstract public class ChannelAction extends Action {
            }
            @Override
            public void onError(ErrorCode errorCode) {
-                sendResponse(errorCode, null);
+                sendResponse(response, errorCode, null);
            }

            @Override
            public void onTimeout() {
-                sendResponse(ErrorCode.ERROR_CODE_TIMEOUT, null);
+                sendResponse(response, ErrorCode.ERROR_CODE_TIMEOUT, null);
            }

            @Override
@@ -29,9 +29,9 @@ import io.netty.util.internal.StringUtil;
 public class GetChannelAction extends ChannelAction {

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
-            setResponseContent(RestResult.ok(OutputGetChannelInfo.fromPbInfo(channelInfo)));
+            setResponseContent(RestResult.ok(OutputGetChannelInfo.fromPbInfo(channelInfo)), response);
        }
        return true;
    }
@@ -31,12 +31,12 @@ import java.util.ArrayList;
 public class GetChannelSubscribersAction extends ChannelAction {

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            OutputStringList outputStringList = new OutputStringList();
            outputStringList.setList(new ArrayList<>());
            outputStringList.getList().addAll(messagesStore.getChannelSubscriber(channelInfo.getTargetId()));
-            setResponseContent(RestResult.ok(outputStringList));
+            setResponseContent(RestResult.ok(outputStringList), response);
        }
        return true;
    }
@@ -31,7 +31,7 @@ import io.netty.util.internal.StringUtil;
 public class GetUserAction extends ChannelAction {

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputGetUserInfo inputUserId = getRequestBody(request.getNettyRequest(), InputGetUserInfo.class);
            if (inputUserId != null
@@ -69,9 +69,9 @@ public class GetUserAction extends ChannelAction {
                    }
                }

-                setResponseContent(result);
+                setResponseContent(result, response);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -28,24 +28,24 @@ import win.liyufan.im.IMTopic;
@HttpMethod("POST")
 public class ModifyChannelProfileAction extends ChannelAction {
    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputModifyChannelInfo input = getRequestBody(request.getNettyRequest(), InputModifyChannelInfo.class);
            if (input != null) {
                WFCMessage.ModifyChannelInfo modifyChannelInfo = WFCMessage.ModifyChannelInfo.newBuilder().setChannelId(channelInfo.getTargetId()).setType(input.getType()).setValue(input.getValue()).build();
-                sendApiMessage(IMTopic.ModifyChannelInfoTopic, modifyChannelInfo.toByteArray(), result -> {
+                sendApiMessage(response, IMTopic.ModifyChannelInfoTopic, modifyChannelInfo.toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
                    if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
-                        sendResponse(null, null);
+                        sendResponse(response, null, null);
                    } else {
-                        sendResponse(errorCode, null);
+                        sendResponse(response, errorCode, null);
                    }
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -40,14 +40,14 @@ public class SendMessageAction extends ChannelAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            SendChannelMessageData sendChannelMessageData = getRequestBody(request.getNettyRequest(), SendChannelMessageData.class);
            if(sendChannelMessageData.getTargets() != null && !sendChannelMessageData.getTargets().isEmpty()) {
                if((channelInfo.getStatus() & ProtoConstants.ChannelState.Channel_State_Mask_Message_Unsubscribed) == 0 && (channelInfo.getStatus() & ProtoConstants.ChannelState.Channel_State_Mask_Global) == 0) {
                    for (String target:sendChannelMessageData.getTargets()) {
                        if(!messagesStore.checkUserInChannel(target, channelInfo.getTargetId())) {
-                            setResponseContent(RestResult.resultOf(ErrorCode.ERROR_CODE_NOT_RIGHT, "User " + target + " not in channel"));
+                            setResponseContent(RestResult.resultOf(ErrorCode.ERROR_CODE_NOT_RIGHT, "User " + target + " not in channel"), response);
                            return true;
                        }
                    }
@@ -63,21 +63,21 @@ public class SendMessageAction extends ChannelAction {
            sendMessageData.setPayload(sendChannelMessageData.getPayload());
            sendMessageData.setToUsers(sendChannelMessageData.getTargets());
            if (SendMessageData.isValide(sendMessageData)) {
-                sendApiMessage(IMTopic.SendMessageTopic, sendMessageData.toProtoMessage().toByteArray(), result -> {
+                sendApiMessage(response, IMTopic.SendMessageTopic, sendMessageData.toProtoMessage().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
                    if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
                        long messageId = byteBuf.readLong();
                        long timestamp = byteBuf.readLong();
-                        sendResponse(null, new SendMessageResult(messageId, timestamp));
+                        sendResponse(response, null, new SendMessageResult(messageId, timestamp));
                    } else {
-                        sendResponse(errorCode, null);
+                        sendResponse(response, errorCode, null);
                    }
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -19,6 +19,7 @@ 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;
@@ -30,7 +31,7 @@ import win.liyufan.im.IMTopic;
 public class SubscriberChannelAction extends ChannelAction {

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputChannelSubscribe input = getRequestBody(request.getNettyRequest(), InputChannelSubscribe.class);
            if (input != null && !StringUtil.isNullOrEmpty(input.getTarget())) {
@@ -41,19 +42,19 @@ public class SubscriberChannelAction extends ChannelAction {
                    return true;
                }
                WFCMessage.ListenChannel listenChannel = WFCMessage.ListenChannel.newBuilder().setChannelId(channelInfo.getTargetId()).setListen(input.getSubscribe()).build();
-                sendApiMessage(input.getTarget(), IMTopic.ChannelListenTopic, listenChannel.toByteArray(), result -> {
+                sendApiMessage(response, input.getTarget(), IMTopic.ChannelListenTopic, listenChannel.toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
                    if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
-                        sendResponse(null, null);
+                        sendResponse(response, null, null);
                    } else {
-                        sendResponse(errorCode, null);
+                        sendResponse(response, errorCode, null);
                    }
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -34,24 +34,24 @@ public class AddGroupMemberAction extends RobotAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputAddGroupMember inputAddGroupMember = getRequestBody(request.getNettyRequest(), InputAddGroupMember.class);
            inputAddGroupMember.setOperator(robot.getUid());
            if (inputAddGroupMember.isValide()) {
-                sendApiRequest(IMTopic.AddGroupMemberTopic, inputAddGroupMember.toProtoGroupRequest().toByteArray(), result -> {
+                sendApiRequest(response, IMTopic.AddGroupMemberTopic, inputAddGroupMember.toProtoGroupRequest().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
                    if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
-                        sendResponse(null, null);
+                        sendResponse(response, null, null);
                    } else {
-                        sendResponse(errorCode, null);
+                        sendResponse(response, errorCode, null);
                    }
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -37,7 +37,7 @@ public class CreateGroupAction extends RobotAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputCreateGroup inputCreateGroup = getRequestBody(request.getNettyRequest(), InputCreateGroup.class);
            inputCreateGroup.setOperator(robot.getUid());
@@ -45,7 +45,7 @@ public class CreateGroupAction extends RobotAction {
            if (inputCreateGroup.isValide()) {
                PojoGroupInfo group_info = inputCreateGroup.getGroup().getGroup_info();
                WFCMessage.CreateGroupRequest createGroupRequest = inputCreateGroup.toProtoGroupRequest();
-                sendApiRequest(IMTopic.CreateGroupTopic, createGroupRequest.toByteArray(), result -> {
+                sendApiRequest(response, IMTopic.CreateGroupTopic, createGroupRequest.toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
@@ -53,14 +53,14 @@ public class CreateGroupAction extends RobotAction {
                        byte[] data = new byte[byteBuf.readableBytes()];
                        byteBuf.readBytes(data);
                        String groupId = new String(data);
-                        sendResponse(null, new OutputCreateGroupResult(groupId));
+                        sendResponse(response, null, new OutputCreateGroupResult(groupId));
                    } else {
-                        sendResponse(errorCode, null);
+                        sendResponse(response, errorCode, null);
                    }
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -26,13 +26,13 @@ import io.netty.util.internal.StringUtil;
 public class DeleteCallbackAction extends RobotAction {

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            if(!StringUtil.isNullOrEmpty(robot.getCallback())) {
                robot = robot.toBuilder().clearCallback().setState(0).build();
                messagesStore.addRobot(robot);
            }
-            setResponseContent(RestResult.ok());
+            setResponseContent(RestResult.ok(), response);
        }
        return true;
    }
@@ -34,24 +34,24 @@ public class DismissGroupAction extends RobotAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputDismissGroup inputDismissGroup = getRequestBody(request.getNettyRequest(), InputDismissGroup.class);
            inputDismissGroup.setOperator(robot.getUid());
            if (inputDismissGroup.isValide()) {
-                sendApiRequest(IMTopic.DismissGroupTopic, inputDismissGroup.toProtoGroupRequest().toByteArray(), result -> {
+                sendApiRequest(response, IMTopic.DismissGroupTopic, inputDismissGroup.toProtoGroupRequest().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
                    if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
-                        sendResponse(null, null);
+                        sendResponse(response, null, null);
                    } else {
-                        sendResponse(errorCode, null);
+                        sendResponse(response, errorCode, null);
                    }
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -29,11 +29,11 @@ import io.netty.util.internal.StringUtil;
 public class GetCallbackAction extends RobotAction {

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            RobotCallbackPojo out = new RobotCallbackPojo();
            out.setUrl(robot.getCallback());
-            setResponseContent(RestResult.ok(out));
+            setResponseContent(RestResult.ok(out), response);
        }
        return true;
    }
@@ -34,7 +34,7 @@ public class GetGroupInfoAction extends RobotAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputGetGroup inputGetGroup = getRequestBody(request.getNettyRequest(), InputGetGroup.class);
            if (inputGetGroup != null
@@ -52,11 +52,15 @@ public class GetGroupInfoAction extends RobotAction {
                    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());
                    result = RestResult.ok(pojoGroupInfo);
                }
-                setResponseContent(result);
+                setResponseContent(result, response);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -39,7 +39,7 @@ public class GetGroupMembersAction extends RobotAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputGetGroup inputGetGroup = getRequestBody(request.getNettyRequest(), InputGetGroup.class);
            String robotId = robot.getUid();
@@ -75,9 +75,9 @@ public class GetGroupMembersAction extends RobotAction {
                    result = RestResult.ok(out);
                }

-                setResponseContent(result);
+                setResponseContent(result, response);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -28,7 +28,7 @@ import cn.wildfirechat.common.ErrorCode;
 public class GetUserAction extends RobotAction {

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputGetUserInfo inputUserId = getRequestBody(request.getNettyRequest(), InputGetUserInfo.class);
            if (inputUserId != null
@@ -49,9 +49,9 @@ public class GetUserAction extends RobotAction {
                } else {
                    result = RestResult.ok(InputOutputUserInfo.fromPbUser(user));
                }
-                setResponseContent(result);
+                setResponseContent(result, response);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -34,24 +34,24 @@ public class KickoffGroupMemberAction extends RobotAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputKickoffGroupMember inputKickoffGroupMember = getRequestBody(request.getNettyRequest(), InputKickoffGroupMember.class);
            inputKickoffGroupMember.setOperator(robot.getUid());
            if (inputKickoffGroupMember.isValide()) {
-                sendApiRequest(IMTopic.KickoffGroupMemberTopic, inputKickoffGroupMember.toProtoGroupRequest().toByteArray(), result -> {
+                sendApiRequest(response, IMTopic.KickoffGroupMemberTopic, inputKickoffGroupMember.toProtoGroupRequest().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
                    if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
-                        sendResponse(null, null);
+                        sendResponse(response, null, null);
                    } else {
-                        sendResponse(errorCode, null);
+                        sendResponse(response, errorCode, null);
                    }
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -34,24 +34,24 @@ public class ModifyGroupInfoAction extends RobotAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputModifyGroupInfo inputAddGroupMember = getRequestBody(request.getNettyRequest(), InputModifyGroupInfo.class);
            inputAddGroupMember.setOperator(robot.getUid());
            if (inputAddGroupMember.isValide()) {
-                sendApiRequest(IMTopic.ModifyGroupInfoTopic, inputAddGroupMember.toProtoGroupRequest().toByteArray(), result -> {
+                sendApiRequest(response, IMTopic.ModifyGroupInfoTopic, inputAddGroupMember.toProtoGroupRequest().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
                    if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
-                        sendResponse(null, null);
+                        sendResponse(response, null, null);
                    } else {
-                        sendResponse(errorCode, null);
+                        sendResponse(response, errorCode, null);
                    }
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -34,24 +34,24 @@ public class ModifyGroupMemberAliasAction extends RobotAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputSetGroupMemberAlias inputSetGroupMemberAlias = getRequestBody(request.getNettyRequest(), InputSetGroupMemberAlias.class);
            inputSetGroupMemberAlias.setOperator(robot.getUid());
            if (inputSetGroupMemberAlias.isValide()) {
-                sendApiRequest(IMTopic.ModifyGroupMemberAliasTopic, inputSetGroupMemberAlias.toProtoGroupRequest().toByteArray(), result -> {
+                sendApiRequest(response, IMTopic.ModifyGroupMemberAliasTopic, inputSetGroupMemberAlias.toProtoGroupRequest().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
                    if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
-                        sendResponse(null, null);
+                        sendResponse(response, null, null);
                    } else {
-                        sendResponse(errorCode, null);
+                        sendResponse(response, errorCode, null);
                    }
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -0,0 +1,61 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <heavyrain.lee@gmail.com>
+ *
+ * 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.InputSetGroupMemberExtra;
+import com.google.gson.Gson;
+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 win.liyufan.im.IMTopic;
+
+@Route(APIPath.Robot_Group_Set_Member_Extra)
+@HttpMethod("POST")
+public class ModifyGroupMemberExtraAction extends RobotAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            InputSetGroupMemberExtra inputSetGroupMemberExtra = getRequestBody(request.getNettyRequest(), InputSetGroupMemberExtra.class);
+            inputSetGroupMemberExtra.setOperator(robot.getUid());
+            if (inputSetGroupMemberExtra.isValide()) {
+                sendApiRequest(response, IMTopic.ModifyGroupMemberExtraTopic, inputSetGroupMemberExtra.toProtoGroupRequest().toByteArray(), result -> {
+                    ByteBuf byteBuf = Unpooled.buffer();
+                    byteBuf.writeBytes(result);
+                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
+                    if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
+                        sendResponse(response, null, null);
+                    } else {
+                        sendResponse(response, errorCode, null);
+                    }
+                });
+                return false;
+            } else {
+                response.setStatus(HttpResponseStatus.OK);
+                RestResult result = RestResult.resultOf(ErrorCode.INVALID_PARAMETER);
+                response.setContent(new Gson().toJson(result));
+            }
+        }
+        return true;
+    }
+}
@@ -34,24 +34,24 @@ public class QuitGroupMemberAction extends RobotAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputQuitGroup inputQuitGroup = getRequestBody(request.getNettyRequest(), InputQuitGroup.class);
            inputQuitGroup.setOperator(robot.getUid());
            if (inputQuitGroup.isValide()) {
-                sendApiRequest(IMTopic.QuitGroupTopic, inputQuitGroup.toProtoGroupRequest().toByteArray(), result -> {
+                sendApiRequest(response, IMTopic.QuitGroupTopic, inputQuitGroup.toProtoGroupRequest().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
                    if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
-                        sendResponse(null, null);
+                        sendResponse(response, null, null);
                    } else {
-                        sendResponse(errorCode, null);
+                        sendResponse(response, errorCode, null);
                    }
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -33,7 +33,6 @@ import java.util.concurrent.Executor;

 abstract public class RobotAction extends Action {
    protected static final Logger LOG = LoggerFactory.getLogger(RobotAction.class);
-    private final RateLimiter mLimitCounter = new RateLimiter(10, 1000);

    protected WFCMessage.Robot robot;

@@ -64,7 +63,7 @@ abstract public class RobotAction extends Action {
            return ErrorCode.ERROR_CODE_API_NOT_SIGNED;
        }

-        if (!mLimitCounter.isGranted(rid)) {
+        if (!robotLimiter.isGranted(rid)) {
            return ErrorCode.ERROR_CODE_OVER_FREQUENCY;
        }

@@ -95,7 +94,7 @@ abstract public class RobotAction extends Action {
        return localSign.equals(sign) ? ErrorCode.ERROR_CODE_SUCCESS : ErrorCode.ERROR_CODE_AUTH_FAILURE;
    }

-    protected void sendResponse(ErrorCode errorCode, Object data) {
+    protected void sendResponse(Response response, ErrorCode errorCode, Object data) {
        response.setStatus(HttpResponseStatus.OK);
        if (errorCode == null) {
            errorCode = ErrorCode.ERROR_CODE_SUCCESS;
@@ -124,7 +123,7 @@ abstract public class RobotAction extends Action {
        return null;
    }

-    protected void sendApiRequest(String topic, byte[] message, Callback callback) {
+    protected void sendApiRequest(Response response, String topic, byte[] message, Callback callback) {
        ServerAPIHelper.sendRequest(robot.getUid(), null, topic, message, new ServerAPIHelper.Callback() {
            @Override
            public void onSuccess(byte[] response) {
@@ -133,12 +132,12 @@ abstract public class RobotAction extends Action {

            @Override
            public void onError(ErrorCode errorCode) {
-                sendResponse(errorCode, null);
+                sendResponse(response, errorCode, null);
            }

            @Override
            public void onTimeout() {
-                sendResponse(ErrorCode.ERROR_CODE_TIMEOUT, null);
+                sendResponse(response, ErrorCode.ERROR_CODE_TIMEOUT, null);
            }

            @Override
@@ -35,26 +35,26 @@ public class SendMessageAction extends RobotAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            SendMessageData sendMessageData = getRequestBody(request.getNettyRequest(), SendMessageData.class);
            sendMessageData.setSender(robot.getUid());
            if (SendMessageData.isValide(sendMessageData)) {
-                sendApiRequest(IMTopic.SendMessageTopic, sendMessageData.toProtoMessage().toByteArray(), result -> {
+                sendApiRequest(response, IMTopic.SendMessageTopic, sendMessageData.toProtoMessage().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
                    if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
                        long messageId = byteBuf.readLong();
                        long timestamp = byteBuf.readLong();
-                        sendResponse(null, new SendMessageResult(messageId, timestamp));
+                        sendResponse(response, null, new SendMessageResult(messageId, timestamp));
                    } else {
-                        sendResponse(errorCode, null);
+                        sendResponse(response, errorCode, null);
                    }
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -27,7 +27,7 @@ import io.netty.util.internal.StringUtil;
 public class SetCallbackAction extends RobotAction {

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            RobotCallbackPojo input = getRequestBody(request.getNettyRequest(), RobotCallbackPojo.class);
            if(!StringUtil.isNullOrEmpty(input.getUrl())) {
@@ -35,9 +35,9 @@ public class SetCallbackAction extends RobotAction {
                    robot = robot.toBuilder().setCallback(input.getUrl()).setState(1).build();
                    messagesStore.addRobot(robot);
                }
-                setResponseContent(RestResult.ok());
+                setResponseContent(RestResult.ok(), response);
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }

        }
@@ -34,24 +34,24 @@ public class TransferGroupAction extends RobotAction {
    }

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            InputTransferGroup inputDismissGroup = getRequestBody(request.getNettyRequest(), InputTransferGroup.class);
            inputDismissGroup.setOperator(robot.getUid());
            if (inputDismissGroup.isValide()) {
-                sendApiRequest(IMTopic.TransferGroupTopic, inputDismissGroup.toProtoGroupRequest().toByteArray(), result -> {
+                sendApiRequest(response, IMTopic.TransferGroupTopic, inputDismissGroup.toProtoGroupRequest().toByteArray(), result -> {
                    ByteBuf byteBuf = Unpooled.buffer();
                    byteBuf.writeBytes(result);
                    ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
                    if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
-                        sendResponse(null, null);
+                        sendResponse(response, null, null);
                    } else {
-                        sendResponse(errorCode, null);
+                        sendResponse(response, errorCode, null);
                    }
                });
                return false;
            } else {
-                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER));
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
            }
        }
        return true;
@@ -28,7 +28,7 @@ import static cn.wildfirechat.pojos.MyInfoType.*;
 public class UpdateProfileAction extends RobotAction {

    @Override
-    public boolean action(Request request) {
+    public boolean action(Request request, Response response) {
        if (request.getNettyRequest() instanceof FullHttpRequest) {
            IntStringPairPojo input = getRequestBody(request.getNettyRequest(), IntStringPairPojo.class);

@@ -85,7 +85,7 @@ public class UpdateProfileAction extends RobotAction {
                    result.setErrorCode(ErrorCode.ERROR_CODE_SERVER_ERROR);
                }
            }
-            setResponseContent(result);
+            setResponseContent(result, response);
        }
        return true;
    }
@@ -53,7 +53,7 @@ abstract public class ActionHandler extends SimpleChannelInboundHandler<FullHttp
 			Action errorAction = ServerSetting.getErrorAction(ServerSetting.MAPPING_ERROR);
 			request.putParam(UnknownErrorAction.ERROR_PARAM_NAME, e);
 			response.setContent(e.toString());
-			errorAction.doAction(request);
+			errorAction.doAction(request, response);

            //如果发送请求未被触发，则触发之，否则跳过。
            if(!response.isSent()){
@@ -134,9 +134,8 @@ abstract public class ActionHandler extends SimpleChannelInboundHandler<FullHttp
 			}
 		}
        action.ctx = ctx;
-		action.response = response;

-		boolean isSync = action.doAction(request);
+		boolean isSync = action.doAction(request, response);

 		if(isSync) {
            //如果发送请求未被触发，则触发之，否则跳过。
@@ -49,7 +49,6 @@ public final class BrokerConstants {
    public static final String DISABLED_PORT_BIND = "disabled";
    public static final String HOST = "0.0.0.0";
    public static final String NEED_CLIENT_AUTH = "need_client_auth";
-    public static final String HAZELCAST_CONFIGURATION = "hazelcast.configuration";
    public static final String HAZELCAST_CLIENT_IP = "hazelcast.client.ip";
    public static final String HAZELCAST_CLIENT_PORT = "hazelcast.client.port";
    public static final String NETTY_SO_BACKLOG_PROPERTY_NAME = "netty.so_backlog";
@@ -85,6 +84,8 @@ public final class BrokerConstants {
    public static final String QINIU_BUCKET_FAVORITE_DOMAIN = "qiniu.bucket_favorite_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";
+
    public static final String USER_QINIU = "media.server.use_qiniu";

    public static final String PUSH_ANDROID_SERVER_ADDRESS = "push.android.server.address";
@@ -127,9 +128,13 @@ public final class BrokerConstants {

    public static final String MESSAGE_Forward_Url = "message.forward.url";
    public static final String MESSAGE_Forward_Types = "message.forward.types";
+    public static final String MESSAGE_MentionMsg_Forward_Url = "message.mentionmsg.forward.url";
+

    public static final String SERVER_MULTI_ENDPOINT = "server.multi_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";

    public static final String MESSAGE_ROAMING = "message.roaming";
    public static final String MESSAGE_Remote_History_Message = "message.remote_history_message";
@@ -140,6 +145,8 @@ public final class BrokerConstants {

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

+    public static final String MESSAGE_NO_Forward_Admin_Message = "message.no_forward_admin_message";
+
    public static final String FRIEND_Disable_Search = "friend.disable_search";
    public static final String FRIEND_Disable_NickName_Search = "friend.disable_nick_name_search";
    public static final String FRIEND_Disable_Friend_Request = "friend.disable_friend_request";
@@ -150,11 +157,14 @@ public final class BrokerConstants {

    public static final String CHATROOM_Participant_Idle_Time = "chatroom.participant_idle_time";
    public static final String CHATROOM_Rejoin_When_Active = "chatroom.rejoin_when_active";
+    public static final String CHATROOM_Create_When_Not_Exist = "chatroom.create_when_not_exist";
+

    public static final String GROUP_Allow_Client_Custom_Operation_Notification = "group.allow_client_custom_operation_notification";
    public static final String GROUP_Visible_Quit_Kickoff_Notification = "group.visible_quit_or_kickoff_notification";

    public static final String USER_HIDE_PROPERTIES = "user.hide_properties";
+    public static final String SYNC_Data_Part_Size = "sync.data_part_size";

    public static final String MESSAGES_FORBIDDEN_CLIENT_SEND_TYPES = "message.forbidden_client_send_types";
    public static final String MESSAGES_BLACKLIST_EXCEPTION_TYPES = "message.blacklist_exception_types";
@@ -162,10 +172,16 @@ public final class BrokerConstants {
    public static final String MESSAGES_GLOBAL_MUTE_EXCEPTION_TYPES = "message.global_mute_exception_types";

    public static final String MESSAGES_DISABLE_REMOTE_SEARCH = "message.disable_remote_search";
+    public static final String MESSAGES_ENCRYPT_MESSAGE_CONTENT = "message.encrypt_message_content";
+

    public static final String MESSAGES_RECALL_TIME_LIMIT = "message.recall_time_limit";
    public static final String MESSAGES_DISABLE_GROUP_MANAGER_RECALL = "message.disable_group_manager_recall";

+    public static final String HTTP_ADMIN_RATE_LIMIT = "http.admin.rate_limit";
+    public static final String HTTP_ROBOT_RATE_LIMIT = "http.robot.rate_limit";
+    public static final String HTTP_CHANNEL_RATE_LIMIT = "http.channel.rate_limit";
+    public static final String CLIENT_REQUEST_RATE_LIMIT = "client.request_rate_limit";

    private BrokerConstants() {
    }
@@ -0,0 +1,33 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <heavyrain.lee@gmail.com>
+ *
+ * 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.WFCMessage;
+import com.hazelcast.util.StringUtil;
+import com.xiaoleilu.loServer.model.FriendData;
+import io.moquette.spi.impl.Qos1PublishHandler;
+import io.netty.buffer.ByteBuf;
+import win.liyufan.im.IMTopic;
+
+import java.util.List;
+
+@Handler(value = IMTopic.ClearSessionTopic)
+public class DisconnectHandler extends IMHandler<Byte> {
+    @Override
+    public ErrorCode action(ByteBuf ackPayload, String clientID, String fromUser, boolean isAdmin, Byte request, Qos1PublishHandler.IMCallback callback) {
+        if (request == 8) {
+            m_sessionsStore.cleanSession(fromUser, clientID);
+        } else if(request == 1) {
+            m_sessionsStore.disableSession(fromUser, clientID);
+        }
+
+        return ErrorCode.ERROR_CODE_SUCCESS;
+    }
+}
@@ -10,12 +10,15 @@ package io.moquette.imhandler;

 import cn.wildfirechat.common.ErrorCode;
 import cn.wildfirechat.proto.WFCMessage;
+import com.hazelcast.util.StringUtil;
 import com.qiniu.util.Auth;
 import com.xiaoleilu.loServer.action.UploadFileAction;
 import io.moquette.server.config.MediaServerConfig;
 import io.moquette.spi.impl.Qos1PublishHandler;
 import io.netty.buffer.ByteBuf;

+import static io.moquette.server.config.MediaServerConfig.FILE_STROAGE_REMOTE_SERVER_URL;
+
@Handler("GMUT")
 public class GetMediaUploadTokenHandler extends IMHandler<WFCMessage.GetUploadTokenRequest> {
    @Override
@@ -80,8 +83,12 @@ public class GetMediaUploadTokenHandler extends IMHandler<WFCMessage.GetUploadTo
            resultBuilder.setPort(80);
        } else {
            token = UploadFileAction.getToken(type);
-            resultBuilder.setDomain("http://" + MediaServerConfig.SERVER_IP + ":" + MediaServerConfig.HTTP_SERVER_PORT)
-                .setServer(MediaServerConfig.SERVER_IP);
+            if(StringUtil.isNullOrEmpty(MediaServerConfig.FILE_STROAGE_REMOTE_SERVER_URL)) {
+                resultBuilder.setDomain("http://" + MediaServerConfig.SERVER_IP + ":" + MediaServerConfig.HTTP_SERVER_PORT);
+            } else {
+                resultBuilder.setDomain(MediaServerConfig.FILE_STROAGE_REMOTE_SERVER_URL);
+            }
+            resultBuilder.setServer(MediaServerConfig.SERVER_IP);
            resultBuilder.setPort(MediaServerConfig.HTTP_SERVER_PORT);
        }

@@ -9,6 +9,7 @@
 package io.moquette.imhandler;

 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;
@@ -21,6 +22,11 @@ public class GetTokenHandler extends IMHandler<WFCMessage.GetTokenRequest> {
    @Override
    public ErrorCode action(ByteBuf ackPayload, String clientID, String fromUser, boolean isAdmin, WFCMessage.GetTokenRequest request, Qos1PublishHandler.IMCallback callback) {
        MemorySessionStore.Session session = m_sessionsStore.updateOrCreateUserSession(fromUser, clientID, request.getPlatform());
+        WFCMessage.User userInfo = m_messagesStore.getUserInfo(fromUser);
+        if(userInfo != null && userInfo.getType() == 1) {
+            return ErrorCode.ERROR_CODE_ROBOT_NO_TOKEN;
+        }
+
        TokenAuthenticator authenticator = new TokenAuthenticator();
        String strToken = authenticator.generateToken(fromUser);
        String result = strToken + "|" + session.getSecret() + "|" + session.getDbSecret();
@@ -19,6 +19,7 @@ import win.liyufan.im.I18n;
 import win.liyufan.im.IMTopic;
 import win.liyufan.im.MessageShardingUtil;

+import static cn.wildfirechat.common.ErrorCode.ERROR_CODE_ALREADY_FRIENDS;
 import static cn.wildfirechat.common.ErrorCode.ERROR_CODE_SUCCESS;

@Handler(IMTopic.HandleFriendRequestTopic)
@@ -37,7 +38,9 @@ public class HandleFriendRequestHandler extends IMHandler<WFCMessage.HandleFrien
                        long timestamp = System.currentTimeMillis();
                        builder.setMessageId(messageId);
                        builder.setServerTimestamp(timestamp);
-                        saveAndPublish(request.getTargetUid(), null, builder.build());
+                        if(!StringUtil.isNullOrEmpty(builder.getContent().getSearchableContent())) {
+                            saveAndPublish(request.getTargetUid(), null, builder.build());
+                        }

                        MemorySessionStore.Session session = m_sessionsStore.getSession(clientID);
                        String language = "zh_CN";
@@ -55,8 +58,7 @@ public class HandleFriendRequestHandler extends IMHandler<WFCMessage.HandleFrien
                        builder.setFromUser(request.getTargetUid());
                        builder.setConversation(WFCMessage.Conversation.newBuilder().setTarget(fromUser).setLine(0).setType(ProtoConstants.ConversationType.ConversationType_Private).build());
                        builder.setContent(contentBuilder);
-                        timestamp = System.currentTimeMillis();
-                        builder.setServerTimestamp(timestamp);
+                        builder.setServerTimestamp(++timestamp);

                        messageId = MessageShardingUtil.generateId();
                        builder.setMessageId(messageId);
@@ -71,10 +73,8 @@ public class HandleFriendRequestHandler extends IMHandler<WFCMessage.HandleFrien
                        builder.setContent(contentBuilder);
                        messageId = MessageShardingUtil.generateId();
                        builder.setMessageId(messageId);
-                        timestamp = System.currentTimeMillis();
-                        builder.setServerTimestamp(timestamp);
+                        builder.setServerTimestamp(++timestamp);
                        saveAndPublish(request.getTargetUid(), null, builder.build());
-
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
@@ -84,6 +84,10 @@ public class HandleFriendRequestHandler extends IMHandler<WFCMessage.HandleFrien
                    publisher.publishNotification(IMTopic.NotifyFriendTopic, fromUser, heads[1]);
                }
            }
+            if(errorCode == ERROR_CODE_ALREADY_FRIENDS) {
+                errorCode = ERROR_CODE_SUCCESS;
+            }
+
            return errorCode;
    }
 }
@@ -38,6 +38,7 @@ import java.util.*;

 import static cn.wildfirechat.common.ErrorCode.ERROR_CODE_OVER_FREQUENCY;
 import static cn.wildfirechat.common.ErrorCode.ERROR_CODE_SUCCESS;
+import static io.moquette.BrokerConstants.CLIENT_REQUEST_RATE_LIMIT;

 /**
 * 请求处理接口<br>
@@ -52,7 +53,7 @@ abstract public class IMHandler<T> {
    protected static Server mServer = null;
    protected static MessagesPublisher publisher;
    private static ThreadPoolExecutorWrapper m_imBusinessExecutor;
-    private static final RateLimiter mLimitCounter = new RateLimiter(5, 100);
+    private static RateLimiter mLimitCounter;
    private Method parseDataMethod;
    private Class dataCls;

@@ -147,12 +148,24 @@ abstract public class IMHandler<T> {
        publisher = p;
        m_imBusinessExecutor = businessExecutor;
        mServer = server;
+        int clientRateLimit = 100;
+        try {
+            clientRateLimit = Integer.parseInt(server.getConfig().getProperty(CLIENT_REQUEST_RATE_LIMIT, "100"));
+        } catch (Exception e) {
+
+        }
+
+        if(clientRateLimit == 0) {
+            clientRateLimit = 100;
+        }
+
+        mLimitCounter = new RateLimiter(5, clientRateLimit);
    }


-    public ErrorCode preAction(String clientID, String fromUser, String topic, Qos1PublishHandler.IMCallback callback) {
+    public ErrorCode preAction(String clientID, String fromUser, String topic, Qos1PublishHandler.IMCallback callback, boolean isAdmin, boolean isRobotOrChannel) {
        LOG.info("imHandler fromUser={}, clientId={}, topic={}", fromUser, clientID, topic);
-        if(!mLimitCounter.isGranted(clientID + fromUser + topic)) {
+        if(!isAdmin && !isRobotOrChannel && !mLimitCounter.isGranted(clientID + fromUser + topic)) {
            ByteBuf ackPayload = Unpooled.buffer();
            ackPayload.ensureWritable(1).writeByte(ERROR_CODE_OVER_FREQUENCY.getCode());
            try {
@@ -166,7 +179,7 @@ abstract public class IMHandler<T> {
        return ErrorCode.ERROR_CODE_SUCCESS;
    }

-	public void doHandler(String clientID, String fromUser, String topic, byte[] payloadContent, Qos1PublishHandler.IMCallback callback, boolean isAdmin) {
+	public void doHandler(String clientID, String fromUser, String topic, byte[] payloadContent, Qos1PublishHandler.IMCallback callback, boolean isAdmin, boolean isRobotOrChannel) {
        m_imBusinessExecutor.execute(() -> {
            Qos1PublishHandler.IMCallback callbackWrapper = new Qos1PublishHandler.IMCallback() {
                @Override
@@ -177,7 +190,7 @@ abstract public class IMHandler<T> {
                }
            };

-            ErrorCode preActionCode = preAction(clientID, fromUser, topic, callbackWrapper);
+            ErrorCode preActionCode = preAction(clientID, fromUser, topic, callbackWrapper, isAdmin, isRobotOrChannel);

            if (preActionCode == ErrorCode.ERROR_CODE_SUCCESS) {
                ByteBuf ackPayload = Unpooled.buffer(1);
@@ -25,7 +25,7 @@ public class ModifyGroupAliasHandler extends GroupHandler<WFCMessage.ModifyGroup
            return ErrorCode.ERROR_CODE_NOT_RIGHT;
        }

-        ErrorCode errorCode = m_messagesStore.modifyGroupAlias(fromUser, request.getGroupId(), request.getAlias(), null, isAdmin);
+        ErrorCode errorCode = m_messagesStore.modifyGroupMemberAlias(fromUser, request.getGroupId(), request.getAlias(), null, isAdmin);
        if (errorCode == ERROR_CODE_SUCCESS) {
            if (request.hasNotifyContent()&& request.getNotifyContent().getType() > 0 && (isAdmin || m_messagesStore.isAllowClientCustomGroupNotification())) {
                sendGroupNotification(fromUser, request.getGroupId(), request.getToLineList(), request.getNotifyContent());
@@ -25,8 +25,8 @@ public class ModifyGroupMemberAliasHandler extends GroupHandler<WFCMessage.Modif
            return ErrorCode.ERROR_CODE_NOT_RIGHT;
        }

-        ErrorCode errorCode = m_messagesStore.modifyGroupAlias(fromUser, request.getGroupId(), request.getAlias(), request.getMemberId(), isAdmin);
-        if (errorCode == ERROR_CODE_SUCCESS && request.hasNotifyContent()) {
+        ErrorCode errorCode = m_messagesStore.modifyGroupMemberAlias(fromUser, request.getGroupId(), request.getAlias(), request.getMemberId(), isAdmin);
+        if (errorCode == ERROR_CODE_SUCCESS) {
            if (request.hasNotifyContent()&& request.getNotifyContent().getType() > 0 && (isAdmin || m_messagesStore.isAllowClientCustomGroupNotification())) {
                sendGroupNotification(fromUser, request.getGroupId(), request.getToLineList(), request.getNotifyContent());
            } else {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
heavyrain2012	c74cddc387	version 0.75	2021-11-17 16:30:25 +08:00
heavyrain2012	b2e4fd9546	update	2021-11-16 16:50:48 +08:00
heavyrain2012	9e8c364642	机器人不允许获取token和登录	2021-11-16 16:49:09 +08:00
heavyrain2012	8127ec03ad	好友欢迎语排序问题	2021-11-10 11:30:06 +08:00
heavyrain2012	c02e9066be	update version 0.74	2021-11-04 15:00:43 +08:00
heavyrain2012	ffd1492ea2	添加限频配置项	2021-10-26 10:11:05 +08:00
heavyrain2012	5e9bbcb1e9	修改注释	2021-10-16 22:20:01 +08:00
heavyrain2012	63770c75fa	修正server api设置好友昵称的问题	2021-10-16 19:43:41 +08:00
heavyrain2012	bf0eb5b8aa	更新注释	2021-10-16 18:12:48 +08:00
heavyrain2012	8cbf66930f	修改注释	2021-10-16 18:11:46 +08:00
heavyrain2012	ce48f67b04	发送好友请求时，如果已经是好友了，返回已经是好友的错误码	2021-10-16 18:03:13 +08:00
heavyrain2012	2fdf11006d	解决双方同时加好友后，有一方接受后，另外一方无法接受问题	2021-10-12 07:59:39 +08:00
heavyrain2012	4a2d7a4cc5	version to 0.73	2021-10-12 07:30:18 +08:00
heavyrain2012	0513da8993	客户端断开链接优化	2021-10-12 07:28:47 +08:00
heavyrain2012	d400b74bff	version to 0.72	2021-10-08 12:05:14 +08:00
heavyrain2012	3d7220d79c	优化disconnect功能	2021-10-08 11:07:08 +08:00
heavyrain2012	4bcf784a6d	优化数据库表结构升级日志提示	2021-09-29 19:50:20 +08:00
heavyrain2012	6d021568d3	add log	2021-09-29 19:39:01 +08:00
heavyrain2012	44f54ecd17	提醒消息判断是不是server api发送	2021-09-29 10:19:24 +08:00
heavyrain2012	4cd0349911	提醒消息转发	2021-09-29 10:17:32 +08:00
heavyrain2012	9ad78f2fb8	支持客户端lite mode	2021-09-27 10:28:58 +08:00
heavyrain2012	b284d10d0f	version to 0.71	2021-09-24 21:20:40 +08:00
heavyrain2012	4fd87eb605	add run time in version info	2021-09-20 21:01:40 +08:00
heavyrain2012	f39fd3abd5	version info add run time	2021-09-20 20:44:04 +08:00
heavyrain2012	db25a6ae04	解决只有pushdata没有pushcontent的推送问题	2021-09-20 08:42:47 +08:00
heavyrain2012	edbed585ce	撤回消息推送	2021-09-20 08:21:16 +08:00
heavyrain2012	9ca69d7318	添加voip免打扰开关	2021-09-20 08:12:26 +08:00
heavyrain2012	eeaa9eefdf	添加开关 1，是否不转发管理员消息 2，客户端是否支持kickoff事件	2021-09-07 22:07:54 +08:00
heavyrain2012	92c9d761ed	add kicked off error code	2021-09-07 08:29:29 +08:00
heavyrain2012	1f9824b283	version to 0.70	2021-09-04 11:23:40 +08:00
heavyrain2012	c7e20632a8	解决单个敏感词无法过滤的问题	2021-09-02 11:55:09 +08:00
heavyrain2012	81a2ab8239	更新命名	2021-09-01 14:48:11 +08:00
heavyrain2012	f62e3f3cef	添加设置用户关系中的附加信息	2021-09-01 14:39:59 +08:00
heavyrain2012	5ce8165514	fix word spell	2021-09-01 13:46:57 +08:00
heavyrain2012	106756ded4	修改敏感词替换错误问题	2021-09-01 13:44:49 +08:00
imndx	3f93be0ece	update readme	2021-08-15 10:48:05 +08:00
heavyrain2012	a53f3eb587	version 0.68 -> 0.69	2021-08-13 17:00:02 +08:00
heavyrain2012	d43afb282e	健康检查	2021-08-13 16:37:16 +08:00
heavyrain2012	2f195440cf	更新健康检查内容	2021-08-13 15:06:09 +08:00
heavyrain2012	d241acf980	添加健康检查功能	2021-08-13 12:36:33 +08:00
heavyrain2012	debd4f1aea	解决配置文件中特殊字符问题	2021-08-05 15:44:20 +08:00
heavyrain2012	5a2ded4b6e	回滚错删的配置	2021-07-28 16:16:11 +08:00
heavyrain2012	ca1bdc9ee5	配置文件添加注释	2021-07-28 15:53:28 +08:00
heavyrain2012	b187151683	完善会议API	2021-07-25 12:08:47 +08:00
heavyrain2012	c3859a9fae	当web/pc在线时，手机默认不发出通知	2021-07-23 11:40:04 +08:00
heavyrain2012	c233304a8f	version 0.67->0.68	2021-07-23 11:21:14 +08:00
heavyrain2012	affc527326	解决文件不存在时出现的异常	2021-07-23 08:28:11 +08:00
heavyrain2012	07fb4ce511	添加注释	2021-07-22 20:18:16 +08:00
heavyrain2012	ce9f2cbafe	添加开关，确定手机是否默认静音当pc或web在线时	2021-07-22 19:38:14 +08:00
heavyrain2012	2ed81ea629	当好友请求原因为空时，在好友请求接受后，不发送此消息	2021-07-22 16:31:15 +08:00
heavyrain2012	2454067fc3	general admin两个用户设置的接口改为public	2021-07-13 10:10:43 +08:00
heavyrain2012	21a0de04ca	不能尝试兼容加密/未加密的消息，因为有可能错误解出消息，导致不可控结果。	2021-07-12 16:36:38 +08:00
heavyrain2012	f8153d68e8	解决获取原创消息揭秘问题	2021-07-12 15:54:31 +08:00
heavyrain2012	a909e79c50	添加配置是否明文存储消息到数据库	2021-07-12 11:20:26 +08:00
heavyrain2012	c58790ebce	去掉控制台的日志输出	2021-07-06 22:43:22 +08:00
heavyrain2012	0f5b0692af	version to 0.67	2021-07-02 11:41:51 +08:00
heavyrain2012	2013e2b6ce	SDK复用链接问题	2021-07-01 15:53:04 +08:00
heavyrain2012	35c040c476	解决server api创建群组有部分参数无效问题	2021-07-01 15:10:13 +08:00
heavyrain2012	31472bc5aa	当聊天室不存在时，加入聊天室自动创建聊天室	2021-06-22 11:05:41 +08:00
heavyrain2012	7e812a095f	添加群组成员修改附加信息的功能	2021-06-19 11:34:49 +08:00
heavyrain2012	ec03b4632a	server api send friend request force参数错误	2021-06-19 11:34:20 +08:00
heavyrain2012	c1d2c77837	修正新引入的错误	2021-06-19 09:15:51 +08:00
heavyrain2012	5f50455169	添加数据库升级提醒	2021-06-16 14:15:24 +08:00
heavyrain2012	499cfe7602	添加Server SDK 配置对象	2021-06-15 16:28:35 +08:00
heavyrain2012	3b98461946	version 0.65 -> 0.66	2021-06-15 10:58:41 +08:00
imhao183	b10ee75da5	SDK支持多个机器人账户	2021-06-09 16:38:15 +08:00
heavyrain.lee	a9792b10ac	Update README.md	2021-06-08 13:13:14 +08:00
imhao183	51bfb788ac	version 0.64 -> 0.65	2021-06-04 18:01:53 +08:00
dependabot[bot]	82088db682	Bump httpclient from 4.4.1 to 4.5.13 in /broker Bumps httpclient from 4.4.1 to 4.5.13. --- updated-dependencies: - dependency-name: org.apache.httpcomponents:httpclient dependency-type: direct:production ... Signed-off-by: dependabot[bot] <[email protected]>	2021-06-04 17:58:45 +08:00
dependabot[bot]	463e3e766a	Bump httpclient from 4.5.3 to 4.5.13 in /sdk Bumps httpclient from 4.5.3 to 4.5.13. --- updated-dependencies: - dependency-name: org.apache.httpcomponents:httpclient dependency-type: direct:production ... Signed-off-by: dependabot[bot] <[email protected]>	2021-06-04 17:58:34 +08:00
imhao183	4b00b873c3	同步会议参数	2021-06-04 17:52:37 +08:00
imhao183	0c06e28116	解决server api强制添加好友请求时被限制的问题	2021-06-04 17:42:17 +08:00
imndx	7ea6ea08fd	update readme	2021-06-01 15:50:07 +08:00
imhao183	b61d292fb5	同步会议API	2021-06-01 08:45:00 +08:00
imhao183	0aba453a24	添加分段同步好友/好友请求/用户设置的功能	2021-05-24 14:44:40 +08:00
imhao183	10ce88de20	更新版本号	2021-05-24 10:31:20 +08:00
imhao183	b0fe3fd57f	解决短链接响应错乱问题	2021-05-24 10:31:09 +08:00
heavyrain2012	141c8f38d8	解决server api 获取群组信息时缺少内容	2021-05-20 11:02:00 +08:00
imhao183	43b325d2d5	添加配置项，可以为内存文件存储添加远程服务地址	2021-05-19 14:02:49 +08:00