update version and release note

This reverts commit ae084063f4.

README.md

@@ -7,9 +7,9 @@
 * 性能强大，专业版IM服务支持百万在线和集群部署，业内顶尖性能水平，详情参考野火性能报告。
 * 部署运维简单，依赖服务少，稍加配置一键启动。
 * 安全加密。网络连接AES加密。客户端数据库SqlCipher加密。安全无小事。
-* 全平台客户端，支持Android、iOS、Web、小程序、UniApp、Flutter、Windows、Mac OS、Linux等所有常见平台。
+* 全平台客户端，支持Android、iOS、鸿蒙、Web、小程序、UniApp、Flutter、Windows、Mac OS、Linux等所有常见平台。
 * 四端同时在线（移动端，pc端，web端和小程序端），数据和状态多端完美同步。
-* 支持国产化。支持国产化操作系统、国产化芯片和国产操作系统。支持国密加密。
+* 支持国产化。支持国产化操作系统、国产化芯片和国产数据库。支持国密加密。
 * 客户端使用微信[mars](https://github.com/tencent/mars)连接库，野火IM可能是最适应中国网络国情的即时通讯服务。
 * 支持加速点加速，即可用于全球应用，也可用于政企内外双网复杂的网络环境。
 * 支持阅读回执和在线状态功能，适用于办公环境。
@@ -22,9 +22,10 @@
 * API丰富，方便与其它服务系统的对接。
 * 拥有机器人和公众号功能，免费的频道（公众号）管理后台。
 * 超级群组功能，可以支持万人大群。
+* 支持多个IM服务组网互通，打破孤岛，适用于集团公司下多个分公司互联互通。
 * 社区版IM服务和移动端免费商用，可以免费构建出完备的移动互联网应用。
 * 收费项目非常便宜，野火独有的试用模式，可以先部署到客户环境试用6个月，试用满意后再购买，避免上当受骗。
-* 技术支持专业和高效，核心研发人员及时处理issue和论坛回复。
+* 技术支持专业高效，***核心研发***及时处理issue和工单，能最快解决用户的技术难题。技术支持不收费，让客户顺利使用是我们最大的愿望。
 
 ## 野火开源项目
 主要包括以下项目：
@@ -43,7 +44,8 @@
 | [organization-platform](https://github.com/wildfirechat/organization-platform)   | [organization-platform](https://gitee.com/wfchat/organization-platform)   | 野火组织通讯录服务。  |
 | [android-chat](https://github.com/wildfirechat/android-chat) | [android-chat](https://gitee.com/wfchat/android-chat) | 野火IM Android SDK源码和App源码。 |
 | [ios-chat](https://github.com/wildfirechat/ios-chat)         | [ios-chat](https://gitee.com/wfchat/ios-chat)         | 野火IM iOS SDK源码和App源码。|
-| [pc-chat](https://github.com/wildfirechat/vue-pc-chat)       | [pc-chat](https://gitee.com/wfchat/vue-pc-chat)       | 基于[Electron](https://electronjs.org/)的PC 端，支持Windows、Mac、Linux（包括国产化linux系统和CPU）。   |
+| [pc-chat(electron)](https://github.com/wildfirechat/vue-pc-chat)       | [pc-chat(electron)](https://gitee.com/wfchat/vue-pc-chat)       | 基于[Electron](https://electronjs.org/)开发的PC 端                   |                         |
+| [pc-chat(Qt)](https://github.com/wildfirechat/qt-pc-chat)       | [pc-chat(Qt)](https://gitee.com/wfchat/qt-pc-chat)       | 基于Qt开发的PC 端                   |                         |
 | [web-chat](https://github.com/wildfirechat/vue-chat)         | [web-chat](https://gitee.com/wfchat/vue-chat)         | 野火IM Web 端, [体验地址](https://web.wildfirechat.cn)。  |
 | [wx-chat](https://github.com/wildfirechat/wx-chat)           | [wx-chat](https://gitee.com/wfchat/wx-chat)           | 小程序平台的Demo(支持微信、百度、阿里、字节、QQ 等小程序平台)。  |
 | [uni-chat](https://github.com/wildfirechat/uni-chat)           | [uni-chat](https://gitee.com/wfchat/uni-chat)           | UniApp平台移动端应用(使用原生插件)。   |
@@ -119,6 +121,19 @@ mvn clean package
 
 修改之后运行编译命令```mvn clean package```，rpm包生成在```distribution/target```目录下。
 
+## Epoll
+在linux系统中打开Epoll开关可以提高性能，默认软件包内打包的是x86_64的epoll native sdk。如果是arm64的机器，可以把[broker pom](./broker/pom.xml)文件中修改如下：
+```xml
+<dependency>
+    <groupId>io.netty</groupId>
+    <artifactId>netty-transport-native-epoll</artifactId>
+    <version>${netty.version}</version>
+<!--    <classifier>linux-x86_64</classifier>-->
+    <classifier>linux-aarch_64</classifier>
+</dependency>
+```
+然后重新打包。专业版IM服务软件包中有arm64架构的sdk，可以直接替换。epoll只支持x86_64和arm64两个架构，其他架构不要把epoll开关打开。
+
 ## 升级说明
 1. 从0.42 版本增加了群成员数限制，默认为2000。如果您从之前的版本升级到这个版本或以后，需要注意到群成员数的限制。升级之后超出限制的群不受影响，但不能继续加人，如果您想修改默认值，可以在升级版本之后，修改t_setting表，把默认的大小改为您期望的人数。另外修改t_group表，把已经存在的群组max_member_count改成您期望的，然后重启。
 2. 0.50版本添加了是否允许客户端发送群操作通知的配置。如果您在客户端自定义群通知，需要在服务器端配置允许，没有使用自定义群操作通知的不受影响。***
@@ -143,6 +158,9 @@ mvn clean package
 ## 服务对象
 因为野火的使用范围比较广，难免被一些不法分子利用，国内反诈反赌力度很大，所以国内多地警方都跟我们都有过联系。***为了预防我们的产品被用于非法目的，试用及购买只能支持境内法人单位，不接受个人或者境外团体。如果我们发现产品被用于非法目的，我们会立即停止技术支持服务并且报警和配合警方调查。请用于非法目的用户绕行！***
 
+## 常见问题
+请参考文档[常见问题](https://docs.wildfirechat.cn/faq/server.html)
+
 ## 应用截图
 登录界面
 

broker/config/wildfirechat.conf

@@ -68,6 +68,10 @@ token.key testim
 ##是否使用AES256加密。默认客户端和服务器都是AES128加密，如果需要开启AES256，需要客户端和IM服务同时开通。
 #encrypt.use_aes256 true
 
+##当创建一个对象时（用户，群组，频道，机器人等），如果没有传入ID，野火会为这个对象生成一个ID。如果id.use_uuid为true，会使用uuid作为对象ID，否则会使用野火短ID，默认为false。
+## 短ID有个很大的风险是容易被人穷举进行攻击。建议用UUID。
+id.use_uuid true
+
 ##首次登录，是否接收之前的历史消息。
 ##0 不接收历史消息，只接收${message.compensate_time_limit}毫秒以内的消息，由于服务器没有保存已经收取记录，所以如果有超过${message.compensate_time_limit}毫秒之前未收取的消息也不会收取下拉；
 ##1接收，会接收 message.max_queue 配置的条数的历史消息
@@ -91,9 +95,15 @@ message.disable_stranger_chat false
 ##当禁止陌生人聊天时，允许聊天的用户id，比如管理员或者文件传输助手等。用户id以英文逗号分割。
 message.allow_stranger_chat_list admin,FireRobot,wfc_file_transfer
 
+##当禁止陌生人聊天时，允许聊天的线路。
+#message.allow_stranger_line 100,101
+
 ##黑名单策略，0 发送失败，返回被拉黑的错误码；1 发送成功但消息被服务器直接丢弃
 message.blacklist.strategy 0
 
+##拉黑对方后，对方不能发送消息给你。这个开关确定拉黑对方后你还能不能给对方发送消息。
+message.blacklist.allow_send_to_black false
+
 ##是否禁止服务器端消息搜索，该功能暂未实现。目前的影响是如果打开，则存储消息时不单独保存_searchable_content字段
 message.disable_remote_search  false
 
@@ -101,7 +111,7 @@ message.disable_remote_search  false
 ##如果要避免数据库中明文存储消息内容，请打开这个开关和message.disable_remote_search开关
 message.encrypt_message_content false
 
-##允许客户端撤回用户自己发送的消息时限，单位是秒。
+##允许客户端撤回用户自己发送的消息时限，单位是秒。0是不允许撤回；-1是无限制撤回。
 ##Server API不受此限制，可以撤回任意时限内的消息
 ##群组管理员或群主撤回群成员消息不受此限制，可以撤回任意时限内的消息。但管理员或群主撤回自己的消息还是需要准守此时间限制。
 ##修改此参数需要同步修改客户端UI，客户端UI代码有判断撤回是否显示的逻辑。
@@ -126,6 +136,12 @@ message.global_mute_exception_types 401,402,403,404,405,407,408,410,411
 ## 离线用户推送过期天数，0是永不过期，建议配置为7天。
 message.push_expired_days 7
 
+## 当会话静音/全局静音/PC在线静音时，普通消息都不会有推送，如果有某些消息类型需要此时保持推送，可以配置到这里。此配置对消息免打扰时段无效。
+## 此配置只影响远程推送，需要客户端处理客户端在线且在后台收到此消息的处理，需要针对这些消息类型加上本地通知。
+## 强制推送消息的MessagePayload中pushContent和pushData至少要存在一个才可以推送。
+## 消息类型以英文逗号分割。
+#message.force_push_types 401,402
+
 ## 群发消息(包括server api群发和全局频道群发)时，目标用户是否来自于t_user表。如果使用野火托管用户信息，请设置为true，否则设置为false。
 message.broadcast.target_from_user_table true
 
@@ -136,12 +152,41 @@ message.no_forward_admin_message false
 ## 消息转发功能开启时，转发信息是否带上用户clientId和平台类型。
 message.forward_with_client_info false
 
+## 消息转发功能开启时，转发信息是否带上发送者的用户信息
+message.forward_with_sender_info false
+
+## 消息转发功能开启时，转发信息是否带上目标的信息，单聊时是对方用户信息，群聊时是群组信息，频道时是频道信息
+message.forward_with_target_info false
+
+## 允许发送单聊消息给被封禁用户
+message.allow_send_to_forbidden_user false
+
 ## 机器人回调信息是否带上用户clientId和平台类型。
 robot.callback_with_client_info false
 
+## 机器人回调信息是否带上发送者的用户信息
+robot.callback_with_sender_info false
+
+## 机器人回调信息是否带上目标的信息，单聊时是对方用户信息，群聊时是群组信息，频道时是频道信息
+robot.callback_with_target_info false
+
+## 是否允许@会话外的机器人。如果为true，单聊或者群聊时，可以@不在会话中的机器人。当机器人收到消息后，可以回复消息。
+## 如果为false，不能@不在会话中的机器人。机器人不在会话中时，也不能回复消息。
+robot.mention_external_robot true
+
 ## 频道回调信息是否带上用户clientId和平台类型。
 channel.callback_with_client_info false
 
+## 频道回调信息是否带上发送者的用户信息。
+channel.callback_with_sender_info false
+
+## 频道回调信息是否带上频道信息
+channel.callback_with_target_info false
+
+## 频道回调新方式，在新方式下，如果有callback地址就会总是回调客户端发送的消息（包括owner和订阅者）。automatic属性控制订阅者发送的消息是否发给owner， 0发，1不发。
+## 旧的方式是，automatic为0时，订阅者的消息发给owner，不转发消息到callback地址。为1时，把订阅者的消息转发给callback地址，不发给owner。
+channel.new_callback_feature true
+
 ##禁止搜索用户
 friend.disable_search false
 
@@ -163,6 +208,9 @@ friend.reject_request_duration 2592000000
 ##好友请求过期时间，单位是毫秒，默认是7天，0为无限长期限。
 friend.request_expiration_duration 604800000
 
+##好友请求限制频率，一个用户24小时之内允许请求好友的次数，默认不限频。
+friend.request_rate_limit 30
+
 ##请求添加机器人为好友时，机器人是否自动接受，默认为true
 friend.robot_auto_accept true
 
@@ -204,6 +252,13 @@ group.visible_quit_or_kickoff_notification 0
 ## 是否禁止陌生人拉人入群，默认为false
 group.disable_stranger_invite false
 
+## 创建群组或者加人时。可能会有成员加入失败（黑名单，或者不允许陌生人拉入群）。当出现有成员失败时，如果此开关为关，操作会失败。
+## 如果此开关打开，操作会返回成功，另外在群里发送一条通知消息 XXX 拒绝加入群组。默认为开。
+group.add_member_allow_part_success true
+
+## 群组信息是否标记删除
+group.enable_mark_deletion true
+
 ## 隐藏用户信息属性类型，2是性别，3是电话号码，4是邮箱，5是地址，6是公司信息，7是社交账号，8是Extra信息。当需要隐藏多个时以英文逗号分开;
 ## 本配置是为了提高安全性，避免把对应信息同步到客户端，这样就能防止程序被破解从而拿到用户关键信息。仅对客户端有效，server api不受影响。
 ## 注意，修改本配置不会对已经同步的信息产生影响。
@@ -241,15 +296,6 @@ client.request_rate_limit 100
 ##关于对象存储的详细信息请参考：https://docs.wildfirechat.cn/server/oss.html
 media.server.use_qiniu 0
 
-##媒体类型分类
-#Media_Type_GENERAL = 0,
-#Media_Type_IMAGE = 1,
-#Media_Type_VOICE = 2,
-#Media_Type_VIDEO = 3,
-#Media_Type_FILE = 4,
-#Media_Type_PORTRAIT = 5,
-#Media_Type_FAVORITE = 6
-
 # qiniu media server configuration
 qiniu.server_url  http://up.qbox.me
 qiniu.access_key tU3vdBK5BL5j4N7jI5N5uZgq_HQDo170w5C9Amnn
@@ -273,11 +319,21 @@ qiniu.bucket_portrait_domain http://cdn2.wildfirechat.cn
 qiniu.bucket_favorite_name storage
 qiniu.bucket_favorite_domain http://cdn2.wildfirechat.cn
 
+##媒体类型分类
+#Media_Type_GENERAL = 0,
+#Media_Type_IMAGE = 1,
+#Media_Type_VOICE = 2,
+#Media_Type_VIDEO = 3,
+#Media_Type_FILE = 4,
+#Media_Type_PORTRAIT = 5,
+#Media_Type_FAVORITE = 6,
+#Media_Type_STICKER = 7,
+#Media_Type_MOMENTS = 8
 
 # local media server configuration
 # 本地媒体服务器配置。
 local.media.storage.root media
-# 如果使用内置文件存储，文件上传后地址默认为 http://server.ip:http_port/fs/5/2021/03/27/08/filename。
+# 如果使用内置文件存储，文件上传后地址默认为 http://server.ip:http_port/fs/5/2021/03/27/08/filename。fs目录下按照类型存放文件，媒体类型见上面注释，比如5就是Media_Type_PORTRAIT，是客户端的头像文件。
 # 如果需要使用nginx添加https支持，请打开下面配置，这样客户端得到的文件地址为 https://example.com/media/fs/5/2021/03/27/08/filename。
 # 需要nginx把请求从https://example.com/media/fs 转到 http://server.ip:http_port/fs。注意需要带上所有header。
 # 尽管内置文件存储可以使用，但是我们还是建议使用专业级别的对象存储服务，社区版可以使用七牛，专业版另外支持阿里云和也是私有对象存储。详情请参考 https://docs.wildfirechat.cn/server/oss.html
@@ -303,7 +359,7 @@ server.mobile_default_silent_when_pc_online true
 
 ## 客户端是否支持kickoff事件。当客户端被其他端登录踢出时，如果此开关为false时，客户端协议栈上报secret_mismatch。如果此开关为ture时，客户端协议栈上报kicked_off。
 ## 客户端被踢时上报kicked_off是在2021.9.15之后才加上的。如果客户端协议栈全部为此日期之后的版本才可以打开此开关。
-server.client_support_kickoff_event false
+server.client_support_kickoff_event true
 
 #*********************************************************************
 # Push server configuration
@@ -317,6 +373,10 @@ push.android.server.address http://localhost:8085/android/push
 ##注意回调是单线程回调，接收服务必须在同一内网，且异步处理快速返回，否则会有延迟问题！！
 push.ios.server.address http://localhost:8085/ios/push
 
+##鸿蒙推送服务器地址
+##注意回调是单线程回调，接收服务必须在同一内网，且异步处理快速返回，否则会有延迟问题！！
+push.harmony.server.address http://localhost:8085/harmony/push
+
 #*********************************************************************
 # 监控配置
 #*********************************************************************
@@ -390,7 +450,14 @@ push.ios.server.address http://localhost:8085/ios/push
 ## 内置文本敏感词过滤处理方法，当命中敏感词后，消息会被记录到t_sensitive_messages表中，然后根据type类型做不同的处理，处理方式如下：
 ## 0 发送失败；1 发送成功但消息被服务器直接丢弃；2 命中的敏感词被替换成***然后正常发送；3 正常发送。
 ## 如果开启 message.sensitive.forward.url 配置，命中敏感词的消息还会被回调到这个地址
-sensitive.filter.type 0
+sensitive.filter.type 2
+
+## 敏感词是否只处理消息。如果为true，只过滤消息；如果为false，会同时过滤用户昵称、群组名和群昵称。
+## 除了消息之外的信息只支持内部敏感词处理，不支持外置审核。
+sensitive.only_message false
+
+## 敏感词添加或者删除有2种方式，一种是通过Server API进行，这种方式会立即生效。另外一种方法是修改数据库，直接中数据库的t_sensitive_word表中处理
+## 修改数据库的方法不会立即生效，IM服务会2个小时重新加载一次敏感词。所以如果直接修改敏感词表，需要等2个小时，或者重启才能生效。
 
 ## 如果内置敏感词库无法满足您的需求，可以开发部署独立敏感词审核服务。配置如下地址和消息类型，IM服务会把指定消息类型的消息回调到指定地址，内置的敏感词审核和敏感词转发功能就不再起作用了。
 ## 审核服务返回状态码200表示继续发送，如果需要替换内容，返回状态码200并且内容为替换后的内容。返回403表示不允许发送。其它错误继续发送。

broker/migrate/h2/V48__group_add_deleted_column.sql

@@ -0,0 +1,2 @@
+alter table `t_group` add column `_deleted` tinyint NOT NULL DEFAULT 0;
+

broker/migrate/h2/V49__add_domain_table.sql

@@ -0,0 +1,13 @@
+DROP TABLE IF EXISTS `t_domain`;
+CREATE TABLE `t_domain` (
+  `_domain_id` varchar(64) NOT NULL PRIMARY KEY,
+  `_name` varchar(64) NOT NULL,
+  `_desc` varchar(256) DEFAULT '',
+  `_email` varchar(64) DEFAULT '',
+  `_tel` varchar(64) DEFAULT '',
+  `_address` varchar(64) DEFAULT '',
+  `_extra` varchar(1024) DEFAULT '',
+  `_dt` bigint(20) NOT NULL
+);
+
+alter table `t_user` add column `_external` tinyint DEFAULT 0;

broker/migrate/h2/V50__update_group_member_index.sql

@@ -0,0 +1 @@
+CREATE INDEX `user_gid_dt_index` ON `t_group_member` (`_gid`, `_dt`);

broker/migrate/h2/V51__add_not_allow_name_setting.sql

@@ -0,0 +1 @@
+insert into t_settings(`id`, `_value`,`_desc`) values (2, '文件传输助手,客服,官方', '禁止使用名称，如果有多个，以英文逗号隔开。直接修改数据库，不用重启IM服务');

broker/migrate/h2/V52__modify_message_target.sql

@@ -0,0 +1 @@
+alter table `t_messages` modify column `_target` varchar(129) NOT NULL;

broker/migrate/mysql/V55__group_add_deleted_column.sql

@@ -0,0 +1 @@
+alter table `t_group` add column `_deleted` tinyint NOT NULL DEFAULT 0;

broker/migrate/mysql/V56__add_domain_table.sql

@@ -0,0 +1,16 @@
+DROP TABLE IF EXISTS `t_domain`;
+CREATE TABLE `t_domain` (
+  `_domain_id` varchar(128) NOT NULL PRIMARY KEY,
+  `_name` varchar(64) NOT NULL,
+  `_desc` varchar(256) DEFAULT '',
+  `_email` varchar(64) DEFAULT '',
+  `_tel` varchar(64) DEFAULT '',
+  `_address` varchar(64) DEFAULT '',
+  `_extra` varchar(1024) DEFAULT '',
+  `_dt` bigint(20) NOT NULL
+)
+ENGINE = InnoDB
+DEFAULT CHARACTER SET = utf8mb4
+COLLATE = utf8mb4_unicode_ci;
+
+alter table `t_user` add column `_external` tinyint DEFAULT 0;

broker/migrate/mysql/V57__update_group_member_index.sql

@@ -0,0 +1 @@
+CREATE INDEX `user_gid_mid_dt_index` ON `t_group_member` (`_gid`, `_mid`, `_dt`);

broker/migrate/mysql/V58__reupdate_group_member_index.sql

@@ -0,0 +1,2 @@
+DROP INDEX `user_gid_mid_dt_index` ON `t_group_member`;
+CREATE INDEX `user_gid_dt_index` ON `t_group_member` (`_gid`, `_dt`);

broker/migrate/mysql/V59__add_no_allow_name_setting.sql

@@ -0,0 +1 @@
+insert into t_settings(`id`, `_value`,`_desc`) values (2, '文件传输助手,客服,官方', '禁止使用名称，如果有多个，以英文逗号隔开。直接修改数据库，不用重启IM服务');

broker/migrate/mysql/V60__modify_messages_target.sql

@@ -0,0 +1,37 @@
+alter table `t_messages` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_0` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_1` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_2` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_3` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_4` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_5` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_6` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_7` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_8` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_9` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_10` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_11` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_12` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_13` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_14` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_15` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_16` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_17` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_18` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_19` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_20` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_21` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_22` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_23` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_24` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_25` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_26` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_27` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_28` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_29` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_30` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_31` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_32` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_33` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_34` modify column `_target` varchar(129) NOT NULL;
+alter table `t_messages_35` modify column `_target` varchar(129) NOT NULL;

broker/nginx/imserver.conf

@@ -9,6 +9,7 @@ server {
     root   html;
     index  index.html index.htm index.php;
 
+    #同步服务设置
     location /route {
         proxy_set_header  Host  $host;
         proxy_set_header  X-real-ip $remote_addr;
@@ -16,7 +17,7 @@ server {
         proxy_pass  http://imserver;
     }
 
-    #社区版需要启用下面一段，专业版不能用
+    #客户端短连接业务
     location /im {
         proxy_set_header  Host  $host;
         proxy_set_header  X-real-ip $remote_addr;
@@ -24,14 +25,21 @@ server {
         proxy_pass  http://imserver;
     }
 
+    #版本检查/api/version，可以删掉
     location /api {
         proxy_pass  http://imserver;
     }
 
+    #内置文件上传和下载
     location /fs {
+        client_max_body_size 200M;
+        proxy_set_header  Host  $host;
+        proxy_set_header  X-real-ip $remote_addr;
+        proxy_set_header  X-Forwarded-For $proxy_add_x_forwarded_for;
         proxy_pass  http://imserver;
     }
 
+    #机器人API
     location /robot {
         proxy_set_header  Host  $host;
         proxy_set_header  X-real-ip $remote_addr;
@@ -39,6 +47,7 @@ server {
         proxy_pass  http://imserver;
     }
 
+    #频道API
     location /channel {
         proxy_set_header  Host  $host;
         proxy_set_header  X-real-ip $remote_addr;

broker/pom.xml

@@ -5,7 +5,7 @@
         <relativePath>../</relativePath>
         <artifactId>wildfirechat-parent</artifactId>
         <groupId>cn.wildfirechat</groupId>
-        <version>1.2.4</version>
+        <version>1.3.9</version>
     </parent>
 
     <artifactId>moquette-broker</artifactId>
@@ -124,9 +124,7 @@
             <artifactId>netty-transport-native-epoll</artifactId>
             <version>${netty.version}</version>
             <classifier>linux-x86_64</classifier>
-            <!--
-            <classifier>${os.detected.name}-${os.detected.arch}</classifier>
-             -->
+<!--            <classifier>linux-aarch_64</classifier>-->
         </dependency>
 
         <dependency>

broker/src/main/java/cn/wildfirechat/push/PushMessage.java

@@ -34,7 +34,10 @@ public class PushMessage {
     public String voipDeviceToken;
     public boolean isHiddenDetail;
     public String language;
+    public boolean republish;
     public long messageId;
+    public long callStartUid;
+    public int existBadgeNumber;
 
     public PushMessage(String sender, int conversationType, String target, int line, int messageContentType, long serverTime, String senderName, String senderPortrait, String targetName, String targetPortrait, int unReceivedMsg, int mentionedType, boolean isHiddenDetail, String language) {
         this.sender = sender;
@@ -65,6 +68,7 @@ public class PushMessage {
         this.mentionedType = mentionedType;
         this.isHiddenDetail = isHiddenDetail;
         this.language = language;
+        this.republish = messageContentType == 80 || messageContentType == 81;
     }
     public PushMessage(String sender, String target, long serverTime, String senderName, int unReceivedMsg, String language, int pushMessageType) {
         this.sender = sender;

broker/src/main/java/cn/wildfirechat/push/PushServer.java

@@ -24,8 +24,7 @@ import win.liyufan.im.Utility;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
-import static io.moquette.BrokerConstants.PUSH_ANDROID_SERVER_ADDRESS;
-import static io.moquette.BrokerConstants.PUSH_IOS_SERVER_ADDRESS;
+import static io.moquette.BrokerConstants.*;
 import static win.liyufan.im.HttpUtils.HttpPostType.POST_TYPE_Push;
 
 public class PushServer {
@@ -47,6 +46,7 @@ public class PushServer {
 
     private String androidPushServerUrl;
     private String iOSPushServerUrl;
+    private String harmonyPushServerUrl;
 
     private PushServer() {
     }
@@ -59,6 +59,7 @@ public class PushServer {
         this.sessionsStore = sessionsStore;
         this.androidPushServerUrl = config.getProperty(PUSH_ANDROID_SERVER_ADDRESS);
         this.iOSPushServerUrl = config.getProperty(PUSH_IOS_SERVER_ADDRESS);
+        this.harmonyPushServerUrl = config.getProperty(PUSH_HARMONY_SERVER_ADDRESS);
     }
 
     public void pushMessage(PushMessage pushMessage, String deviceId, String pushContent) {
@@ -80,10 +81,6 @@ public class PushServer {
         }
 
         MemorySessionStore.Session session = sessionsStore.getSession(deviceId);
-        int badge = session.getUnReceivedMsgs();
-        if (badge <= 0) {
-            badge = 1;
-        }
         if (StringUtil.isNullOrEmpty(session.getDeviceToken())) {
             LOG.warn("Device token is empty for device {}", deviceId);
             return;
@@ -93,7 +90,6 @@ public class PushServer {
         pushMessage.pushType = session.getPushType();
         pushMessage.pushContent = pushContent;
         pushMessage.deviceToken = session.getDeviceToken();
-        pushMessage.unReceivedMsg = badge;
         pushMessage.userId = session.getUsername();
         if (session.getPlatform() == ProtoConstants.Platform.Platform_iOS ||
             session.getPlatform() == ProtoConstants.Platform.Platform_iPad ||
@@ -106,6 +102,8 @@ public class PushServer {
             if (session.getPlatform() == ProtoConstants.Platform.Platform_iOS || session.getPlatform() == ProtoConstants.Platform.Platform_iPad) {
                 url = iOSPushServerUrl;
                 pushMessage.voipDeviceToken = session.getVoipDeviceToken();
+            } else if (session.getPlatform() == ProtoConstants.Platform.Platform_Harmony || session.getPlatform() == ProtoConstants.Platform.Platform_HarmonyPad) {
+                url = harmonyPushServerUrl;
             }
             HttpUtils.httpJsonPost(url, gson.toJson(pushMessage, pushMessage.getClass()), POST_TYPE_Push);
         } else {

broker/src/main/java/com/xiaoleilu/loServer/action/Action.java

@@ -8,9 +8,13 @@
 
 package com.xiaoleilu.loServer.action;
 
+import cn.wildfirechat.common.IMExceptionEvent;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
+import com.google.gson.JsonSyntaxException;
 import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.action.channel.ChannelAction;
+import com.xiaoleilu.loServer.action.robot.RobotAction;
 import com.xiaoleilu.loServer.annotation.RequireAuthentication;
 import com.xiaoleilu.loServer.handler.Request;
 import com.xiaoleilu.loServer.handler.Response;
@@ -23,7 +27,10 @@ import io.netty.handler.codec.http.FullHttpRequest;
 import io.netty.handler.codec.http.HttpRequest;
 import io.netty.handler.codec.http.HttpResponseStatus;
 import cn.wildfirechat.common.ErrorCode;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import win.liyufan.im.RateLimiter;
+import win.liyufan.im.Utility;
 
 import java.nio.charset.StandardCharsets;
 
@@ -38,6 +45,7 @@ import static io.moquette.BrokerConstants.*;
  */
 
 abstract public class Action {
+    private static final Logger LOG = LoggerFactory.getLogger(Action.class);
     public static IMessagesStore messagesStore = null;
     public static ISessionsStore sessionsStore = null;
     protected static final Gson gson = new GsonBuilder().disableHtmlEscaping().create();
@@ -153,9 +161,22 @@ abstract public class Action {
             FullHttpRequest fullHttpRequest = (FullHttpRequest) request;
             byte[] bytes = Utils.readBytesAndRewind(fullHttpRequest.content());
             String content = new String(bytes, StandardCharsets.UTF_8);//contribute by JiaRG from github
-            
-            T t = gson.fromJson(content, cls);
-            return t;
+
+            try {
+                T t = gson.fromJson(content, cls);
+                return t;
+            } catch (JsonSyntaxException e) {
+                e.printStackTrace();
+                LOG.error("Object {} from json {} failure", cls.getName(), content);
+                int exception = IMExceptionEvent.EventType.ADMIN_API_Exception;
+                if (this instanceof RobotAction) {
+                    exception = IMExceptionEvent.EventType.ROBOT_API_Exception;
+                } else if (this instanceof ChannelAction) {
+                    exception = IMExceptionEvent.EventType.CHANNEL_API_Exception;
+                }
+                Utility.printExecption(LOG, e, exception);
+                throw new RuntimeException(e);
+            }
         }
         return null;
     }

broker/src/main/java/com/xiaoleilu/loServer/action/FileAction.java

@@ -1,8 +1,11 @@
 package com.xiaoleilu.loServer.action;
 
 import java.io.File;
+import java.io.IOException;
 import java.io.UnsupportedEncodingException;
 import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.nio.file.Files;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.Locale;
@@ -13,6 +16,7 @@ import cn.hutool.core.io.FileUtil;
 import cn.hutool.core.util.ReUtil;
 import cn.hutool.core.util.StrUtil;
 import com.hazelcast.core.HazelcastInstance;
+import com.hazelcast.util.StringUtil;
 import com.xiaoleilu.loServer.ServerSetting;
 import com.xiaoleilu.loServer.handler.Request;
 import com.xiaoleilu.loServer.handler.Response;
@@ -90,11 +94,26 @@ public class FileAction extends Action {
         }
 
         response.setContent(file);
-        response.setHeader("Content-Disposition", "attachment; filename=\"" + file.getName() + "\"");
+        if (isAudioOrVideoFile(file.getName())) {
+            response.setHeader("Accept-Ranges", "bytes");
+        } else {
+            response.setHeader("Content-Disposition", "attachment; filename=\"" + file.getName() + "\"");
+        }
 
         return true;
     }
 
+    private static boolean isAudioOrVideoFile(String name) {
+        try {
+            if (StringUtil.isNullOrEmpty(name)) return false;
+
+            String mimeType = Files.probeContentType(new File(name).toPath());
+            return mimeType != null && (mimeType.startsWith("audio/") || mimeType.startsWith("video/"));
+        } catch (IOException e) {
+            return false;
+        }
+    }
+
     private static final Pattern INSECURE_URI = Pattern.compile(".*[<>&\"].*");
 	private static final SimpleDateFormat HTTP_DATE_FORMATER = new SimpleDateFormat(HTTP_DATETIME_PATTERN, Locale.US);
 

broker/src/main/java/com/xiaoleilu/loServer/action/UploadFileAction.java

@@ -284,9 +284,10 @@ public class UploadFileAction extends Action {
 
                         savedThunkSize += readableBytesSize;
                         offset += readableBytesSize;
+                        byteBuf.release();
+                        byteBuf = null;
 
                         if (savedThunkSize >= remoteFileSize) {
-                            byteBuf.release();
                             fileUpload.release();
 
                             response.setStatus(HttpResponseStatus.OK);

broker/src/main/java/com/xiaoleilu/loServer/action/admin/AliasPutAction.java

@@ -51,14 +51,7 @@ public class AliasPutAction extends AdminAction {
                     ByteBuf byteBuf = Unpooled.buffer();
                     byteBuf.writeBytes(result);
                     ErrorCode errorCode = ErrorCode.fromCode(byteBuf.readByte());
-                    if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
-                        byte[] data = new byte[byteBuf.readableBytes()];
-                        byteBuf.readBytes(data);
-                        String channelId = new String(data);
-                        return new Result(ErrorCode.ERROR_CODE_SUCCESS, new OutputCreateChannel(channelId));
-                    } else {
-                        return new Result(errorCode);
-                    }
+                    return new Result(errorCode);
                 });
                 return false;
             } else {

broker/src/main/java/com/xiaoleilu/loServer/action/admin/CreateChannelAction.java

@@ -53,8 +53,11 @@ public class CreateChannelAction extends AdminAction {
                     if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
                         byte[] data = new byte[byteBuf.readableBytes()];
                         byteBuf.readBytes(data);
-                        String channelId = new String(data);
-                        return new Result(ErrorCode.ERROR_CODE_SUCCESS, new OutputCreateChannel(channelId));
+                        String str = new String(data);
+                        String[] ss = str.split("\\|");
+                        String channelId = ss[0];
+                        String secret = ss[1];
+                        return new Result(ErrorCode.ERROR_CODE_SUCCESS, new OutputCreateChannel(channelId, secret));
                     } else {
                         return new Result(errorCode);
                     }

broker/src/main/java/com/xiaoleilu/loServer/action/admin/GetBatchUserAction.java

@@ -0,0 +1,61 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.admin;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.*;
+import cn.wildfirechat.proto.WFCMessage;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.handler.codec.http.HttpResponseStatus;
+import io.netty.util.internal.StringUtil;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+@Route(APIPath.User_Batch_Get_Infos)
+@HttpMethod("POST")
+public class GetBatchUserAction extends AdminAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            InputStringList inputUserId = getRequestBody(request.getNettyRequest(), InputStringList.class);
+            if (inputUserId != null && inputUserId.getList() != null && !inputUserId.getList().isEmpty()) {
+
+                OutputUserInfoList res = new OutputUserInfoList();
+                res.userInfos = new ArrayList<>();
+                for (String userId : inputUserId.getList()) {
+                    WFCMessage.User user = messagesStore.getUserInfo(userId);
+                    if(user == null || StringUtil.isNullOrEmpty(user.getName())) {
+                        continue;
+                    }
+                    InputOutputUserInfo inputOutputUserInfo = InputOutputUserInfo.fromPbUser(user);
+                    res.userInfos.add(inputOutputUserInfo);
+                }
+                RestResult result = RestResult.ok(res);
+                setResponseContent(result, response);
+            } else {
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
+            }
+        }
+        return true;
+    }
+}

broker/src/main/java/com/xiaoleilu/loServer/action/admin/GetGroupInfoAction.java

@@ -53,6 +53,7 @@ public class GetGroupInfoAction extends AdminAction {
                     pojoGroupInfo.setPortrait(groupInfo.getPortrait());
                     pojoGroupInfo.setTarget_id(groupInfo.getTargetId());
                     pojoGroupInfo.setType(groupInfo.getType());
+                    pojoGroupInfo.setMember_count(groupInfo.getMemberCount());
                     pojoGroupInfo.setMute(groupInfo.getMute());
                     pojoGroupInfo.setJoin_type(groupInfo.getJoinType());
                     pojoGroupInfo.setPrivate_chat(groupInfo.getPrivateChat());
@@ -60,6 +61,9 @@ public class GetGroupInfoAction extends AdminAction {
                     pojoGroupInfo.setMax_member_count(groupInfo.getMemberCount());
                     pojoGroupInfo.setHistory_message(groupInfo.getHistoryMessage());
                     pojoGroupInfo.setSuper_group(groupInfo.getSuperGroup()>0);
+                    pojoGroupInfo.setDeleted(groupInfo.getDeleted()>0);
+                    pojoGroupInfo.setUpdate_dt(groupInfo.getUpdateDt());
+                    pojoGroupInfo.setMember_update_dt(groupInfo.getMemberUpdateDt());
                     result = RestResult.ok(pojoGroupInfo);
                 }
                 setResponseContent(result, response);

broker/src/main/java/com/xiaoleilu/loServer/action/admin/GetIMTokenAction.java

@@ -20,6 +20,7 @@ import io.netty.handler.codec.http.FullHttpRequest;
 import cn.wildfirechat.common.ErrorCode;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import win.liyufan.im.GitRepositoryState;
 import win.liyufan.im.IMTopic;
 
 import java.util.Base64;
@@ -53,7 +54,7 @@ public class GetIMTokenAction extends AdminAction {
 
                     LOG.info("get im token success {},{},{}", userId, input.getClientId(), token.substring(0, Math.min(10, token.length())));
                     
-                    return new Result(errorCode1, new OutputGetIMTokenData(userId, token));
+                    return new Result(errorCode1, new OutputGetIMTokenData(userId, token, GitRepositoryState.globalLabel));
                 } else {
                     return new Result(errorCode1);
                 }

broker/src/main/java/com/xiaoleilu/loServer/action/admin/GetUsersByEmailAction.java

@@ -0,0 +1,66 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.admin;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.InputGetUserInfo;
+import cn.wildfirechat.pojos.InputOutputUserInfo;
+import cn.wildfirechat.pojos.OutputUserInfoList;
+import cn.wildfirechat.proto.WFCMessage;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.util.internal.StringUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Route(APIPath.User_Get_Email_Info)
+@HttpMethod("POST")
+public class GetUsersByEmailAction extends AdminAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            String email = getRequestBody(request.getNettyRequest(), String.class);
+            if (!StringUtil.isNullOrEmpty(email)) {
+
+                List<WFCMessage.User> users = messagesStore.getUserInfosByEmail(email);
+                List<InputOutputUserInfo> list = new ArrayList<>();
+                for (WFCMessage.User user : users) {
+                    list.add(InputOutputUserInfo.fromPbUser(user));
+                }
+
+                RestResult result;
+                if (list.isEmpty()) {
+                    result = RestResult.resultOf(ErrorCode.ERROR_CODE_NOT_EXIST);
+                } else {
+                    OutputUserInfoList outputUserInfoList = new OutputUserInfoList();
+                    outputUserInfoList.userInfos = list;
+                    result = RestResult.ok(outputUserInfoList);
+                }
+
+                setResponseContent(result, response);
+            } else {
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
+            }
+
+        }
+        return true;
+    }
+}

broker/src/main/java/com/xiaoleilu/loServer/action/admin/SendMessageAction.java

@@ -51,7 +51,7 @@ public class SendMessageAction extends AdminAction {
                     } else {
                         return new Result(errorCode);
                     }
-                });
+                }, sendMessageData.isUserMessage());
                 return false;
             } else {
                 setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);

broker/src/main/java/com/xiaoleilu/loServer/action/channel/ChannelAction.java

@@ -105,18 +105,6 @@ abstract public class ChannelAction extends Action {
         response.send();
     }
 
-    protected <T> T getRequestBody(HttpRequest request, Class<T> cls) {
-        if (request instanceof FullHttpRequest) {
-            FullHttpRequest fullHttpRequest = (FullHttpRequest) request;
-            byte[] bytes = Utils.readBytesAndRewind(fullHttpRequest.content());
-            String content = new String(bytes, StandardCharsets.UTF_8);
-            
-            T t = gson.fromJson(content, cls);
-            return t;
-        }
-        return null;
-    }
-
     protected void sendApiMessage(Response response, String topic, byte[] message, Callback callback) {
         sendApiMessage(response, channelInfo.getOwner(), topic, message, callback);
     }

broker/src/main/java/com/xiaoleilu/loServer/action/robot/GetGroupInfoAction.java

@@ -52,10 +52,17 @@ public class GetGroupInfoAction extends RobotAction {
                     pojoGroupInfo.setPortrait(groupInfo.getPortrait());
                     pojoGroupInfo.setTarget_id(groupInfo.getTargetId());
                     pojoGroupInfo.setType(groupInfo.getType());
+                    pojoGroupInfo.setMember_count(groupInfo.getMemberCount());
                     pojoGroupInfo.setMute(groupInfo.getMute());
                     pojoGroupInfo.setJoin_type(groupInfo.getJoinType());
                     pojoGroupInfo.setPrivate_chat(groupInfo.getPrivateChat());
                     pojoGroupInfo.setSearchable(groupInfo.getSearchable());
+                    pojoGroupInfo.setMax_member_count(groupInfo.getMemberCount());
+                    pojoGroupInfo.setHistory_message(groupInfo.getHistoryMessage());
+                    pojoGroupInfo.setSuper_group(groupInfo.getSuperGroup()>0);
+                    pojoGroupInfo.setDeleted(groupInfo.getDeleted()>0);
+                    pojoGroupInfo.setUpdate_dt(groupInfo.getUpdateDt());
+                    pojoGroupInfo.setMember_update_dt(groupInfo.getMemberUpdateDt());
                     result = RestResult.ok(pojoGroupInfo);
                 }
                 setResponseContent(result, response);

broker/src/main/java/com/xiaoleilu/loServer/action/robot/ReplyMessageAction.java

@@ -0,0 +1,112 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.robot;
+
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.Conversation;
+import cn.wildfirechat.pojos.ReplyMessageData;
+import cn.wildfirechat.pojos.SendMessageData;
+import cn.wildfirechat.pojos.SendMessageResult;
+import cn.wildfirechat.proto.ProtoConstants;
+import cn.wildfirechat.proto.WFCMessage;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.handler.codec.http.HttpResponseStatus;
+import org.jetbrains.annotations.NotNull;
+import win.liyufan.im.IMTopic;
+
+import java.util.Arrays;
+
+@Route(APIPath.Robot_Message_Reply)
+@HttpMethod("POST")
+public class ReplyMessageAction extends RobotAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            ReplyMessageData replyMessageData = getRequestBody(request.getNettyRequest(), ReplyMessageData.class);
+            if (ReplyMessageData.isValide(replyMessageData)) {
+                WFCMessage.Message message = messagesStore.getMessage(replyMessageData.getMessageUid());
+                ErrorCode errorCode = null;
+                if(message == null) {
+                    errorCode = ErrorCode.ERROR_CODE_NOT_EXIST;
+                } else if(!message.getContent().getMentionedTargetList().contains(robot.getUid())) {
+                    errorCode = ErrorCode.ERROR_CODE_INVALID_MESSAGE;
+                } else if(message.getConversation().getType() != ProtoConstants.ConversationType.ConversationType_Private && message.getConversation().getType() != ProtoConstants.ConversationType.ConversationType_Group) {
+                    errorCode = ErrorCode.ERROR_CODE_NOT_IMPLEMENT;
+                } else if(System.currentTimeMillis() - message.getServerTimestamp() > 15*60*1000) {
+                    errorCode = ErrorCode.ERROR_CODE_RECALL_TIME_EXPIRED;
+                } else if(!messagesStore.isRobotMentionExternalRobot()) {
+                    if(message.getConversation().getType() != ProtoConstants.ConversationType.ConversationType_Group) {
+                        errorCode = ErrorCode.ERROR_CODE_NOT_IMPLEMENT;
+                    } else {
+                        WFCMessage.GroupMember member = messagesStore.getGroupMember(message.getConversation().getTarget(), robot.getUid());
+                        if(member == null || member.getType() == ProtoConstants.GroupMemberType.GroupMemberType_Removed) {
+                            errorCode = ErrorCode.ERROR_CODE_NOT_IMPLEMENT;
+                        }
+                    }
+                }
+
+                if(errorCode != null) {
+                    response.setStatus(HttpResponseStatus.OK);
+                    RestResult result = RestResult.resultOf(errorCode);
+                    response.setContent(gson.toJson(result));
+                    return true;
+                }
+
+                SendMessageData sendMessageData = getSendMessageData(message, replyMessageData);
+                WFCMessage.Message newMsg = sendMessageData.toProtoMessage().toBuilder().setMessageId(message.getMessageId()).build();
+                sendApiRequest(response, IMTopic.RobotReplyMessageTopic, newMsg.toByteArray(), result -> {
+                    ByteBuf byteBuf = Unpooled.buffer();
+                    byteBuf.writeBytes(result);
+                    ErrorCode ec = ErrorCode.fromCode(byteBuf.readByte());
+                    if (ec == ErrorCode.ERROR_CODE_SUCCESS) {
+                        long messageId = byteBuf.readLong();
+                        long timestamp = byteBuf.readLong();
+                        sendResponse(response, null, new SendMessageResult(messageId, timestamp));
+                    } else {
+                        sendResponse(response, ec, null);
+                    }
+                });
+                return false;
+            } else {
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
+            }
+        }
+        return true;
+    }
+
+    private @NotNull SendMessageData getSendMessageData(WFCMessage.Message message, ReplyMessageData replyMessageData) {
+        SendMessageData sendMessageData = new SendMessageData();
+        sendMessageData.setSender(robot.getUid());
+        Conversation conversation = new Conversation();
+        conversation.setType(message.getConversation().getType());
+        conversation.setLine(message.getConversation().getLine());
+        conversation.setTarget(message.getConversation().getTarget());
+        sendMessageData.setConv(conversation);
+        sendMessageData.setPayload(replyMessageData.getPayload());
+        if(replyMessageData.isOnly2Sender()) {
+            sendMessageData.setToUsers(Arrays.asList(message.getFromUser()));
+        }
+        return sendMessageData;
+    }
+}

broker/src/main/java/com/xiaoleilu/loServer/action/robot/RobotAction.java

@@ -106,24 +106,6 @@ abstract public class RobotAction extends Action {
         response.send();
     }
 
-    protected <T> T getRequestBody(HttpRequest request, Class<T> cls) {
-        if (request instanceof FullHttpRequest) {
-            FullHttpRequest fullHttpRequest = (FullHttpRequest) request;
-            byte[] bytes = Utils.readBytesAndRewind(fullHttpRequest.content());
-            String content = null;
-            try {
-                content = new String(bytes, "UTF-8");
-                
-                T t = gson.fromJson(content, cls);
-                return t;
-            } catch (UnsupportedEncodingException e) {
-                e.printStackTrace();
-                Utility.printExecption(LOG, e, IMExceptionEvent.EventType.ROBOT_API_Exception);
-            }
-        }
-        return null;
-    }
-
     protected void sendApiRequest(Response response, String topic, byte[] message, Callback callback) {
         ServerAPIHelper.sendRequest(robot.getUid(), null, topic, message, new ServerAPIHelper.Callback() {
             @Override

broker/src/main/java/com/xiaoleilu/loServer/action/robot/UpdateProfileAction.java

@@ -80,6 +80,7 @@ public class UpdateProfileAction extends RobotAction {
             RestResult result = RestResult.ok();
             if(modified) {
                 try {
+                    builder.setUpdateDt(System.currentTimeMillis());
                     messagesStore.updateUserInfo(builder.build());
                 } catch (Exception e) {
                     e.printStackTrace();

broker/src/main/java/io/moquette/BrokerConstants.java

@@ -90,6 +90,7 @@ public final class BrokerConstants {
 
     public static final String PUSH_ANDROID_SERVER_ADDRESS = "push.android.server.address";
     public static final String PUSH_IOS_SERVER_ADDRESS = "push.ios.server.address";
+    public static final String PUSH_HARMONY_SERVER_ADDRESS = "push.harmony.server.address";
 
     public static final String MONITOR_Exception_Event_Address = "monitor.exception_event_address";
 
@@ -115,13 +116,15 @@ public final class BrokerConstants {
     public static final String CONNECT_CLIENT_SIGNATURE_LIST = "connect.client_signature_list";
     public static final String CONNECT_REJECT_EMPTY_SIGNATURE = "connect.reject_empty_signature";
 
+    public static final String ID_USE_UUID = "id.use_uuid";
+
     public static final String EMBED_DB_PROPERTY_NAME = "embed.db";
     public static final String DB_AUTO_CLEAN_HISTORY_MESSAGES = "db.auto_clean_history_messages";
     public static final String H2DB_PATH = "h2db.path";
 
 
     public static final String SENSITIVE_Filter_Type = "sensitive.filter.type";
-
+    public static final String SENSITIVE_Only_Message = "sensitive.only_message";
     public static final String SENSITIVE_Remote_Server_URL = "sensitive.remote_server_url";
     public static final String SENSITIVE_Remote_Message_Type = "sensitive.remote_sensitive_message_type";
     public static final String SENSITIVE_Remote_Fail_When_Matched = "sensitive.remote_fail_when_matched";
@@ -149,19 +152,35 @@ public final class BrokerConstants {
 
     public static final String MESSAGE_Disable_Stranger_Chat = "message.disable_stranger_chat";
     public static final String MESSAGE_Allow_Stranger_Chat_List = "message.allow_stranger_chat_list";
+    public static final String MESSAGE_Allow_Stranger_Line = "message.allow_stranger_line";
 
     public static final String MESSAGE_Blacklist_Strategy = "message.blacklist.strategy";
+    public static final String MESSAGE_Blacklist_Allow_Send = "message.blacklist.allow_send_to_black";
 
     public static final String MESSAGE_NO_Forward_Admin_Message = "message.no_forward_admin_message";
 
     public static final String MESSAGE_Push_Expired_Days = "message.push_expired_days";
+    public static final String MESSAGE_Force_Push_Types = "message.force_push_types";
 
     public static final String MESSAGE_Forward_With_Client_Info = "message.forward_with_client_info";
+    public static final String MESSAGE_Forward_With_Sender_Info = "message.forward_with_sender_info";
+    public static final String MESSAGE_Forward_With_Target_Info = "message.forward_with_target_info";
 
     public static final String BROADCAST_Target_From_User_Table = "message.broadcast.target_from_user_table";
 
+    public static final String MESSAGES_ALLOW_SEND_TO_FORBIDDEN_USER = "message.allow_send_to_forbidden_user";
+
     public static final String ROBOT_Callback_With_Client_Info = "robot.callback_with_client_info";
+    public static final String ROBOT_Callback_With_Sender_Info = "robot.callback_with_sender_info";
+    public static final String ROBOT_Callback_With_Target_Info = "robot.callback_with_target_info";
+    public static final String ROBOT_Mention_External_Robot = "robot.mention_external_robot";
+
+
     public static final String CHANNEL_Callback_With_Client_Info = "channel.callback_with_client_info";
+    public static final String CHANNEL_Callback_With_Sender_Info = "channel.callback_with_sender_info";
+    public static final String CHANNEL_Callback_With_Target_Info = "channel.callback_with_target_info";
+    public static final String CHANNEL_New_Callback_Feature = "channel.new_callback_feature";
+
 
     public static final String FRIEND_Disable_Search = "friend.disable_search";
     public static final String FRIEND_Disable_NickName_Search = "friend.disable_nick_name_search";
@@ -170,6 +189,7 @@ public final class BrokerConstants {
     public static final String FRIEND_Repeat_Request_Duration = "friend.repeat_request_duration";
     public static final String FRIEND_Reject_Request_Duration = "friend.reject_request_duration";
     public static final String FRIEND_Request_Expiration_Duration = "friend.request_expiration_duration";
+    public static final String FRIEND_Request_Rate_Limit = "friend.request_rate_limit";
     public static final String FRIEND_Request_Robot_Auto_Accept = "friend.robot_auto_accept";
 
 
@@ -187,6 +207,9 @@ public final class BrokerConstants {
     public static final String GROUP_Forbidden_Client_Operation = "group.forbidden_client_operation";
 
     public static final String GROUP_Disable_Stranger_Invite = "group.disable_stranger_invite";
+    public static final String GROUP_ADD_MEMBER_ALLOW_PART_SUCCESS = "group.add_member_allow_part_success";
+
+    public static final String GROUP_INFO_MARK_DELETION = "group.enable_mark_deletion";
 
     public static final String USER_HIDE_PROPERTIES = "user.hide_properties";
     public static final String USER_KEEP_DISPLAY_NAME_WHEN_DESTROY = "user.keep_display_name_when_destroy";

broker/src/main/java/io/moquette/imhandler/AddFriendHandler.java

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

broker/src/main/java/io/moquette/imhandler/AddGroupMember.java

@@ -16,6 +16,10 @@ import io.netty.buffer.ByteBuf;
 import cn.wildfirechat.common.ErrorCode;
 import win.liyufan.im.IMTopic;
 
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
 import static cn.wildfirechat.common.ErrorCode.ERROR_CODE_SUCCESS;
 
 @Handler(value = IMTopic.AddGroupMemberTopic)
@@ -38,16 +42,34 @@ public class AddGroupMember extends GroupHandler<WFCMessage.AddGroupMemberReques
             }
         }
 
-        ErrorCode errorCode = m_messagesStore.addGroupMembers(fromUser, isAdmin, request.getGroupId(), request.getAddedMemberList(), request.getExtra());
+        Map<String, Integer> failedMembers = new HashMap<>();
+        if(requestSourceType == ProtoConstants.RequestSourceType.Request_From_User) {
+            ErrorCode errorCode = m_messagesStore.canAddGroupMembers(fromUser, request.getAddedMemberList(), failedMembers);
+            if (errorCode != ErrorCode.ERROR_CODE_SUCCESS) {
+                return errorCode;
+            }
+        }
+
+        ErrorCode errorCode = m_messagesStore.addGroupMembers(fromUser, isAdmin, request.getGroupId(), request.getAddedMemberList(), request.getExtra(), failedMembers);
         if (errorCode == ERROR_CODE_SUCCESS) {
             if (request.hasNotifyContent() && request.getNotifyContent().getType() > 0) {
                 sendGroupNotification(fromUser, request.getGroupId(), request.getToLineList(), request.getNotifyContent());
             } else {
-                WFCMessage.MessageContent content = new GroupNotificationBinaryContent(request.getGroupId(), fromUser, null, getMemberIdList(request.getAddedMemberList())).getAddGroupNotifyContent();
+                List<String> added = getMemberIdList(request.getAddedMemberList());
+                added.removeAll(failedMembers.keySet());
+                WFCMessage.MessageContent content = new GroupNotificationBinaryContent(request.getGroupId(), fromUser, null, added).setExtra(request.getExtra()).getAddGroupNotifyContent();
                 sendGroupNotification(fromUser, request.getGroupId(), request.getToLineList(), content);
             }
         }
 
+        if (errorCode == ERROR_CODE_SUCCESS && !failedMembers.isEmpty()) {
+            WFCMessage.MessageContent content = new GroupNotificationBinaryContent(request.getGroupId(), fromUser, null, "").setMi(failedMembers).getGroupNotifyContent(ProtoConstants.MESSAGE_CONTENT_TYPE_REJECT_JOIN_GROUP);
+            sendGroupNotification(fromUser, request.getGroupId(), request.getToLineList(), content);
+        }
+
+        if(errorCode == ERROR_CODE_SUCCESS && !failedMembers.isEmpty()) {
+            return ErrorCode.ERROR_CODE_PARTLY_SUCCESS;
+        }
         return errorCode;
     }
 }

broker/src/main/java/io/moquette/imhandler/CreateChannelHandler.java

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

broker/src/main/java/io/moquette/imhandler/CreateGroupHandler.java

@@ -17,6 +17,10 @@ import io.netty.buffer.ByteBuf;
 import cn.wildfirechat.common.ErrorCode;
 import win.liyufan.im.IMTopic;
 
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
 @Handler(value = IMTopic.CreateGroupTopic)
 public class CreateGroupHandler extends GroupHandler<WFCMessage.CreateGroupRequest> {
     @Override
@@ -27,7 +31,7 @@ public class CreateGroupHandler extends GroupHandler<WFCMessage.CreateGroupReque
 
         if (!StringUtil.isNullOrEmpty(request.getGroup().getGroupInfo().getTargetId())) {
             WFCMessage.GroupInfo existGroupInfo = m_messagesStore.getGroupInfo(request.getGroup().getGroupInfo().getTargetId());
-            if (existGroupInfo != null) {
+            if (existGroupInfo != null && existGroupInfo.getDeleted() == 0) {
                 return ErrorCode.ERROR_CODE_GROUP_ALREADY_EXIST;
             }
         }
@@ -51,24 +55,54 @@ public class CreateGroupHandler extends GroupHandler<WFCMessage.CreateGroupReque
             }
         }
 
+        Map<String, Integer> failedMembers = new HashMap<>();
         if(requestSourceType == ProtoConstants.RequestSourceType.Request_From_User) {
-            ErrorCode errorCode = m_messagesStore.canAddGroupMembers(fromUser, request.getGroup().getMembersList());
+            ErrorCode errorCode = m_messagesStore.canAddGroupMembers(fromUser, request.getGroup().getMembersList(), failedMembers);
             if (errorCode != ErrorCode.ERROR_CODE_SUCCESS) {
                 return errorCode;
             }
         }
 
-        WFCMessage.GroupInfo groupInfo = m_messagesStore.createGroup(fromUser, request.getGroup().getGroupInfo(), request.getGroup().getMembersList(), request.getMemberExtra(), isAdmin);
-        if (groupInfo != null) {
+        if (request.getGroup().getGroupInfo().getTargetId().length() > 64
+            || request.getGroup().getGroupInfo().getName().length() > 64
+            || request.getGroup().getGroupInfo().getPortrait().length() > 1024) {
+            return ErrorCode.INVALID_PARAMETER;
+        }
+
+        if(!isAdmin && !StringUtil.isNullOrEmpty(request.getGroup().getGroupInfo().getName())) {
+            if(!m_messagesStore.isSensitiveOnlyMessage()) {
+                Set<String> matched = m_messagesStore.handleSensitiveWord(request.getGroup().getGroupInfo().getName());
+                if (matched != null && !matched.isEmpty()) {
+                    return ErrorCode.ERROR_CODE_SENSITIVE_MATCHED;
+                }
+            }
+
+            if(!m_messagesStore.isAllowName(request.getGroup().getGroupInfo().getName())) {
+                return ErrorCode.ERROR_CODE_NOT_RIGHT;
+            }
+        }
+
+        WFCMessage.GroupInfo groupInfo = m_messagesStore.createGroup(fromUser, request.getGroup().getGroupInfo(), request.getGroup().getMembersList(), request.getMemberExtra(), isAdmin, failedMembers);
+        if (groupInfo != null && groupInfo.getDeleted() == 0) {
             if(request.hasNotifyContent() && request.getNotifyContent().getType() > 0) {
                 sendGroupNotification(fromUser, groupInfo.getTargetId(), request.getToLineList(), request.getNotifyContent());
             } else {
-                WFCMessage.MessageContent content = new GroupNotificationBinaryContent(groupInfo.getTargetId(), fromUser, groupInfo.getName(), "").getCreateGroupNotifyContent();
+                WFCMessage.MessageContent content = new GroupNotificationBinaryContent(groupInfo.getTargetId(), fromUser, groupInfo.getName(), "").setExtra(request.getMemberExtra()).getCreateGroupNotifyContent();
+                sendGroupNotification(fromUser, groupInfo.getTargetId(), request.getToLineList(), content);
+            }
+
+            if(!failedMembers.isEmpty()) {
+                WFCMessage.MessageContent content = new GroupNotificationBinaryContent(groupInfo.getTargetId(), fromUser, null, "").setMi(failedMembers).getGroupNotifyContent(ProtoConstants.MESSAGE_CONTENT_TYPE_REJECT_JOIN_GROUP);
                 sendGroupNotification(fromUser, groupInfo.getTargetId(), request.getToLineList(), content);
             }
         }
+
         byte[] data = groupInfo.getTargetId().getBytes();
         ackPayload.ensureWritable(data.length).writeBytes(data);
-        return ErrorCode.ERROR_CODE_SUCCESS;
+        if(failedMembers.isEmpty()) {
+            return ErrorCode.ERROR_CODE_SUCCESS;
+        } else {
+            return ErrorCode.ERROR_CODE_PARTLY_SUCCESS;
+        }
     }
 }

broker/src/main/java/io/moquette/imhandler/ModifyGroupAliasHandler.java

@@ -11,11 +11,14 @@ package io.moquette.imhandler;
 import cn.wildfirechat.proto.ProtoConstants;
 import cn.wildfirechat.proto.WFCMessage;
 import cn.wildfirechat.pojos.GroupNotificationBinaryContent;
+import com.hazelcast.util.StringUtil;
 import io.moquette.spi.impl.Qos1PublishHandler;
 import io.netty.buffer.ByteBuf;
 import cn.wildfirechat.common.ErrorCode;
 import win.liyufan.im.IMTopic;
 
+import java.util.Set;
+
 import static cn.wildfirechat.common.ErrorCode.ERROR_CODE_SUCCESS;
 
 @Handler(IMTopic.ModifyGroupAliasTopic)
@@ -26,10 +29,24 @@ public class ModifyGroupAliasHandler extends GroupHandler<WFCMessage.ModifyGroup
         if(request.hasNotifyContent() && request.getNotifyContent().getType() > 0 && requestSourceType == ProtoConstants.RequestSourceType.Request_From_User && !m_messagesStore.isAllowClientCustomGroupNotification()) {
             return ErrorCode.ERROR_CODE_NOT_RIGHT;
         }
+
         if(request.hasNotifyContent() && request.getNotifyContent().getType() > 0 && requestSourceType == ProtoConstants.RequestSourceType.Request_From_Robot && !m_messagesStore.isAllowRobotCustomGroupNotification()) {
             return ErrorCode.ERROR_CODE_NOT_RIGHT;
         }
 
+        if (!isAdmin && !StringUtil.isNullOrEmpty(request.getAlias())) {
+            if(!m_messagesStore.isSensitiveOnlyMessage()) {
+                Set<String> matched = m_messagesStore.handleSensitiveWord(request.getAlias());
+                if (matched != null && !matched.isEmpty()) {
+                    return ErrorCode.ERROR_CODE_SENSITIVE_MATCHED;
+                }
+            }
+
+            if(!m_messagesStore.isAllowName(request.getAlias())) {
+                return ErrorCode.ERROR_CODE_NOT_RIGHT;
+            }
+        }
+
         ErrorCode errorCode = m_messagesStore.modifyGroupMemberAlias(fromUser, request.getGroupId(), request.getAlias(), null, isAdmin);
         if (errorCode == ERROR_CODE_SUCCESS) {
             if (request.hasNotifyContent()&& request.getNotifyContent().getType() > 0) {

broker/src/main/java/io/moquette/imhandler/ModifyGroupMemberAliasHandler.java

@@ -12,10 +12,13 @@ import cn.wildfirechat.common.ErrorCode;
 import cn.wildfirechat.pojos.GroupNotificationBinaryContent;
 import cn.wildfirechat.proto.ProtoConstants;
 import cn.wildfirechat.proto.WFCMessage;
+import com.hazelcast.util.StringUtil;
 import io.moquette.spi.impl.Qos1PublishHandler;
 import io.netty.buffer.ByteBuf;
 import win.liyufan.im.IMTopic;
 
+import java.util.Set;
+
 import static cn.wildfirechat.common.ErrorCode.ERROR_CODE_SUCCESS;
 
 @Handler(IMTopic.ModifyGroupMemberAliasTopic)
@@ -29,6 +32,18 @@ public class ModifyGroupMemberAliasHandler extends GroupHandler<WFCMessage.Modif
         if(request.hasNotifyContent() && request.getNotifyContent().getType() > 0 && requestSourceType == ProtoConstants.RequestSourceType.Request_From_Robot && !m_messagesStore.isAllowRobotCustomGroupNotification()) {
             return ErrorCode.ERROR_CODE_NOT_RIGHT;
         }
+        if (!isAdmin && !StringUtil.isNullOrEmpty(request.getAlias())) {
+            if(!m_messagesStore.isSensitiveOnlyMessage()) {
+                Set<String> matched = m_messagesStore.handleSensitiveWord(request.getAlias());
+                if (matched != null && !matched.isEmpty()) {
+                    return ErrorCode.ERROR_CODE_SENSITIVE_MATCHED;
+                }
+            }
+
+            if(!m_messagesStore.isAllowName(request.getAlias())) {
+                return ErrorCode.ERROR_CODE_NOT_RIGHT;
+            }
+        }
 
         ErrorCode errorCode = m_messagesStore.modifyGroupMemberAlias(fromUser, request.getGroupId(), request.getAlias(), request.getMemberId(), isAdmin);
         if (errorCode == ERROR_CODE_SUCCESS) {

broker/src/main/java/io/moquette/imhandler/QuitGroupHandler.java

@@ -43,13 +43,13 @@ public class QuitGroupHandler extends GroupHandler<WFCMessage.QuitGroupRequest>
             if (request.hasNotifyContent() && request.getNotifyContent().getType() > 0) {
                 sendGroupNotification(fromUser, request.getGroupId(), request.getToLineList(), request.getNotifyContent());
             } else {
-                WFCMessage.MessageContent content = new GroupNotificationBinaryContent(request.getGroupId(), fromUser, null, "").getQuitGroupNotifyContent();
+                WFCMessage.MessageContent content = new GroupNotificationBinaryContent(request.getGroupId(), fromUser, request.getKeepMsg()>0?"1":"0", "").getQuitGroupNotifyContent();
                 sendGroupNotification(fromUser, request.getGroupId(), request.getToLineList(), content);
             }
 
             if((m_messagesStore.getVisibleQuitKickoffNotification() & 0x01) > 0) {
                 Set<String> toUsers = m_messagesStore.getGroupManagers(request.getGroupId(), true);
-                WFCMessage.MessageContent content = new GroupNotificationBinaryContent(request.getGroupId(), fromUser, null, "").getQuitVisibleGroupNotifyContent();
+                WFCMessage.MessageContent content = new GroupNotificationBinaryContent(request.getGroupId(), fromUser, request.getKeepMsg()>0?"1":"0", "").getQuitVisibleGroupNotifyContent();
                 sendGroupNotification(fromUser, request.getGroupId(), request.getToLineList(), content, toUsers);
             }
         }

broker/src/main/java/io/moquette/imhandler/ReplyMessageHandler.java

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

broker/src/main/java/io/moquette/imhandler/SendMessageHandler.java

@@ -37,7 +37,9 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
     private Set<Integer> mForwardExcludeMessageTypes = new HashSet<>();
     private String mMentionForwardUrl = null;
     private int mBlacklistStrategy = 0; //黑名单中时，0失败，1吞掉。
+    private boolean mBlacklistAllowSend2Black = true;
     private boolean mNoForwardAdminMessage = false;
+    private boolean mAllowSend2ForbiddenUser = false;
 
     private String mRemoteSensitiveServerUrl = null;
     private Set<Integer> mRemoteSensitiveMessageTypes;
@@ -69,6 +71,12 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
             e.printStackTrace();
             Utility.printExecption(LOG, e);
         }
+
+        try {
+            mBlacklistAllowSend2Black = Boolean.parseBoolean(mServer.getConfig().getProperty(BrokerConstants.MESSAGE_Blacklist_Allow_Send, "true"));
+        } catch (Exception e) {
+        }
+
         try {
             mRemoteSensitiveServerUrl = mServer.getConfig().getProperty(BrokerConstants.SENSITIVE_Remote_Server_URL);
             if(!StringUtil.isNullOrEmpty(mRemoteSensitiveServerUrl)) {
@@ -94,6 +102,9 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
             Utility.printExecption(LOG, e);
         }
 
+        try {
+            mAllowSend2ForbiddenUser = Boolean.parseBoolean(mServer.getConfig().getProperty(BrokerConstants.MESSAGES_ALLOW_SEND_TO_FORBIDDEN_USER, "false"));
+        } catch (Exception e) {}
     }
 
     private void parseTypes(Collection<Integer> collection, String types) {
@@ -125,6 +136,15 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
         ErrorCode errorCode = ErrorCode.ERROR_CODE_SUCCESS;
         boolean isAdmin = requestSourceType == ProtoConstants.RequestSourceType.Request_From_Admin;
         if (message != null) {
+            if(message.getContent().getContent().length() +
+                message.getContent().getSearchableContent().length() +
+                message.getContent().getData().size() +
+                message.getContent().getExtra().length() +
+                message.getContent().getPushContent().length() +
+                message.getContent().getPushData().length() > 64 * 1024) {
+                return ErrorCode.ERROR_CODE_MESSAGE_TOO_LARGE;
+            }
+
             boolean ignoreMsg = false;
             if (!isAdmin) {  //admin do not check the right
                 // 不能在端上直接发送撤回和群通知
@@ -145,7 +165,7 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
 
                 if (message.getConversation().getType() == ProtoConstants.ConversationType.ConversationType_Private) {
                     if(!m_messagesStore.getBlackListExceptionTypes().contains(message.getContent().getType())) {
-                        errorCode = m_messagesStore.isAllowUserMessage(message.getConversation().getTarget(), fromUser);
+                        errorCode = m_messagesStore.isAllowUserMessage(message.getConversation().getTarget(), fromUser, message.getConversation().getLine());
                         if (errorCode != ErrorCode.ERROR_CODE_SUCCESS) {
                             if (errorCode == ErrorCode.ERROR_CODE_IN_BLACK_LIST && mBlacklistStrategy != ProtoConstants.BlacklistStrategy.Message_Reject) {
                                 ignoreMsg = true;
@@ -154,11 +174,20 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
                                 return errorCode;
                             }
                         }
+
+                        if(!mBlacklistAllowSend2Black) {
+                            errorCode = m_messagesStore.isBlacked(fromUser, message.getConversation().getTarget());
+                            if (errorCode != ErrorCode.ERROR_CODE_SUCCESS) {
+                                return errorCode;
+                            }
+                        }
                     }
 
-                    userStatus = m_messagesStore.getUserStatus(message.getConversation().getTarget());
-                    if (userStatus == ProtoConstants.UserStatus.Forbidden) {
-                        return ErrorCode.ERROR_CODE_USER_FORBIDDEN;
+                    if (!mAllowSend2ForbiddenUser) {
+                        userStatus = m_messagesStore.getUserStatus(message.getConversation().getTarget());
+                        if (userStatus == ProtoConstants.UserStatus.Forbidden) {
+                            return ErrorCode.ERROR_CODE_USER_FORBIDDEN;
+                        }
                     }
                 }
 
@@ -203,20 +232,13 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
             }
             message = message.toBuilder().setFromUser(fromUser).setMessageId(messageId).setServerTimestamp(timestamp).build();
 
-            OutputClient outputClient = null;
-            if(m_messagesStore.isForwardMessageWithClientInfo() && requestSourceType == ProtoConstants.RequestSourceType.Request_From_User && !StringUtil.isNullOrEmpty(clientID)) {
-                MemorySessionStore.Session session = m_sessionsStore.getSession(clientID);
-                if(session != null && session.getUsername().equals(fromUser)) {
-                    outputClient = new OutputClient(session.getPlatform(), clientID);
-                }
-            }
 
             if (!StringUtil.isNullOrEmpty(mForwardUrl) && (mForwardMessageTypes.isEmpty() || mForwardMessageTypes.contains(message.getContent().getType())) && !(isAdmin && mNoForwardAdminMessage) && !mForwardExcludeMessageTypes.contains(message.getContent().getType())) {
-                publisher.forwardMessage(message, mForwardUrl, outputClient);
+                publisher.forwardMessage(message, mForwardUrl, clientID);
             }
 
             if(!StringUtil.isNullOrEmpty(mMentionForwardUrl) && message.hasContent() && message.getContent().getMentionedType() != 0 && !(isAdmin && mNoForwardAdminMessage)) {
-                publisher.forwardMessage(message, mMentionForwardUrl, outputClient);
+                publisher.forwardMessage(message, mMentionForwardUrl, clientID);
             }
 
             if (!isAdmin) {
@@ -225,7 +247,7 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
                     if (matched != null && !matched.isEmpty()) {
                         m_messagesStore.storeSensitiveMessage(message);
                         if (!StringUtil.isNullOrEmpty(mSensitiveMessageForwardUrl)) {
-                            publisher.forwardMessage(message, mSensitiveMessageForwardUrl, outputClient);
+                            publisher.forwardMessage(message, mSensitiveMessageForwardUrl, clientID);
                         }
                         if (mSensitiveType == 0) {
                             errorCode = ErrorCode.ERROR_CODE_SENSITIVE_MATCHED;
@@ -242,7 +264,7 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
                 } else {
                     if(mRemoteSensitiveMessageTypes.contains(message.getContent().getType())) {
                         final WFCMessage.Message finalMsg = message;
-                        publisher.forwardMessageWithCallback(message, mRemoteSensitiveServerUrl, new HttpUtils.HttpCallback() {
+                        publisher.forwardMessageWithCallback(message, clientID, mRemoteSensitiveServerUrl, new HttpUtils.HttpCallback() {
                             @Override
                             public void onSuccess(String content) {
                                 if(StringUtil.isNullOrEmpty(content)) {

broker/src/main/java/io/moquette/imhandler/UserSearchHandler.java

@@ -21,7 +21,7 @@ import java.util.List;
 public class UserSearchHandler extends IMHandler<WFCMessage.SearchUserRequest> {
     @Override
     public ErrorCode action(ByteBuf ackPayload, String clientID, String fromUser, ProtoConstants.RequestSourceType requestSourceType, WFCMessage.SearchUserRequest request, Qos1PublishHandler.IMCallback callback) {
-        List<WFCMessage.User> users = m_messagesStore.searchUser(request.getKeyword(), request.getFuzzy(), request.getPage());
+        List<WFCMessage.User> users = m_messagesStore.searchUser(request.getKeyword(), request.getFuzzy(), request.getType(), request.getPage());
         WFCMessage.SearchUserResult.Builder builder = WFCMessage.SearchUserResult.newBuilder();
         builder.addAllEntry(users);
         byte[] data = builder.build().toByteArray();

broker/src/main/java/io/moquette/persistence/DatabaseStore.java

@@ -36,6 +36,9 @@ import java.util.function.Function;
 
 import static cn.wildfirechat.common.IMExceptionEvent.EventType.RDBS_Exception;
 import static cn.wildfirechat.proto.ProtoConstants.PersistFlag.Transparent;
+import static cn.wildfirechat.proto.ProtoConstants.UserSearchUserType.UserSearchUserType_ONLY_ROBOT;
+import static cn.wildfirechat.proto.ProtoConstants.UserSearchUserType.UserSearchUserType_ONLY_USER;
+import static io.moquette.BrokerConstants.GROUP_INFO_MARK_DELETION;
 import static io.moquette.server.Constants.MAX_MESSAGE_QUEUE;
 import static cn.wildfirechat.proto.ProtoConstants.SearchUserType.*;
 import static win.liyufan.im.UserSettingScope.kUserSettingPrivacySearchable;
@@ -45,6 +48,7 @@ public class DatabaseStore {
     private final ThreadPoolExecutorWrapper mScheduler;
     private boolean disableRemoteMessageSearch = false;
     private boolean encryptMessage = false;
+    private boolean keepGroupInfo = false;
     public void setDisableRemoteMessageSearch(boolean disableRemoteMessageSearch) {
         this.disableRemoteMessageSearch = disableRemoteMessageSearch;
     }
@@ -55,6 +59,11 @@ public class DatabaseStore {
 
     public DatabaseStore(ThreadPoolExecutorWrapper scheduler) {
         this.mScheduler = scheduler;
+        try {
+            keepGroupInfo = Boolean.parseBoolean(Server.getServer().getConfig().getProperty(GROUP_INFO_MARK_DELETION, "false"));
+        } catch (Exception e) {
+
+        }
     }
 
     TreeMap<Long, Long> reloadUserMessageMaps(String userId) {
@@ -162,7 +171,7 @@ public class DatabaseStore {
         return null;
     }
 
-    List<WFCMessage.User> searchUserByNameMobileUserId(String keyword, int searchType) {
+    List<WFCMessage.User> searchUserByNameMobileUserId(String keyword, int searchType, int userType) {
         ArrayList<WFCMessage.User> out = new ArrayList<>();
         Connection connection = null;
         PreparedStatement statement = null;
@@ -196,7 +205,15 @@ public class DatabaseStore {
                 sql += " where (`_name` = ? or `_mobile` = ? or `_uid` = ?) ";
             }
 
-            sql += " and `_type` <> 2 and `_deleted` = 0"; //can search normal user(0) and robot(1) and admin(100), can not search things
+            if(userType == UserSearchUserType_ONLY_USER) {
+                sql += " and _type <> 2 "; //can not search device
+                sql += " and _type <> 1 ";
+            } else if(userType == UserSearchUserType_ONLY_ROBOT) {
+                sql += " and _type = 1 ";
+            } else {
+                sql += " and _type <> 2 "; //can not search device
+            }
+            sql += " and _deleted = 0 ";
 
             if(searchType == SearchUserType_Name || searchType == SearchUserType_Mobile || searchType == SearchUserType_UserId) {
                 sql += " limit 1";
@@ -401,7 +418,7 @@ public class DatabaseStore {
         return out;
     }
 
-    List<WFCMessage.User> searchUserByDisplayName(String keyword, int page, List<WFCMessage.User> nameOrIdMatched) {
+    List<WFCMessage.User> searchUserByDisplayName(String keyword, int userType, int page, List<WFCMessage.User> nameOrIdMatched) {
         Connection connection = null;
         PreparedStatement statement = null;
         ResultSet rs = null;
@@ -412,7 +429,18 @@ public class DatabaseStore {
             connection = DBUtil.getConnection();
             String sql = "select u._uid, u._name, u._display_name, u._portrait, u._mobile, u._gender, u._email, u._address, u._company, u._social, u._extra, u._dt, u._type " +
                 " from t_user u left join (select _uid, _value from t_user_setting where _scope = 27) s on u._uid = s._uid " +
-                " where u._display_name like ? ESCAPE '!' and u._type <> 2 and u._deleted = 0 ";
+                " where u._display_name like ? ESCAPE '!' ";
+
+            if(userType == UserSearchUserType_ONLY_USER) {
+                sql += " and u._type <> 2 ";
+                sql += " and u._type <> 1 ";
+            } else if(userType == UserSearchUserType_ONLY_ROBOT) {
+                sql += " and u._type = 1 ";
+            } else {
+                sql += " and u._type <> 2 ";
+            }
+            sql += " and u._deleted = 0 ";
+
             if(nameOrIdMatched.size() == 1) {
                 sql += " and u._uid <> ? and u._name <> ?";
             } else if(nameOrIdMatched.size() == 2) {
@@ -516,15 +544,15 @@ public class DatabaseStore {
         return out;
     }
 
-    List<WFCMessage.User> searchUserFromDB(String keyword, int searchType, int page) {
-        List<WFCMessage.User> nameOrIdMatched = searchUserByNameMobileUserId(keyword, searchType);
+    List<WFCMessage.User> searchUserFromDB(String keyword, int searchType, int userType, int page) {
+        List<WFCMessage.User> nameOrIdMatched = searchUserByNameMobileUserId(keyword, searchType, userType);
         List<WFCMessage.User> out = new ArrayList<>();
         if(page == 0) {
             out.addAll(nameOrIdMatched);
         }
 
         if(searchType == SearchUserType_General || searchType == SearchUserType_Name_Mobile_DisplayName) {
-            List<WFCMessage.User> general = searchUserByDisplayName(keyword, page, nameOrIdMatched);
+            List<WFCMessage.User> general = searchUserByDisplayName(keyword, userType, page, nameOrIdMatched);
             general.removeAll(nameOrIdMatched);
             out.addAll(general);
         }
@@ -1129,7 +1157,16 @@ public class DatabaseStore {
                 }
 
                 if (!expired) {
-                    messages.add(message);
+                    boolean duplicated = false;
+                    for (WFCMessage.Message msg : messages) {
+                        if(message.getMessageId() == msg.getMessageId()) {
+                            duplicated = true;
+                            break;
+                        }
+                    }
+                    if(!duplicated) {
+                        messages.add(message);
+                    }
                 }
             }
 
@@ -1425,7 +1462,8 @@ public class DatabaseStore {
                 ", `_join_type`" +
                 ", `_private_chat`" +
                 ", `_searchable`" +
-                ", `_member_dt`) values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)" +
+                ", `_deleted`" +
+                ", `_member_dt`) values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)" +
                 " ON DUPLICATE KEY UPDATE " +
                 "`_name` = ?," +
                 "`_portrait` = ?," +
@@ -1436,8 +1474,9 @@ public class DatabaseStore {
                 "`_mute` = ?" +
                 ", `_join_type` = ?" +
                 ", `_private_chat` = ?" +
-                ", `_searchable` = ?, " +
-                "`_member_dt` = ?";
+                ", `_searchable` = ?" +
+                ", `_deleted` = ?" +
+                ", `_member_dt` = ?";
 
 
             statement = connection.prepareStatement(sql);
@@ -1455,6 +1494,7 @@ public class DatabaseStore {
             statement.setInt(index++, groupInfo.getJoinType());
             statement.setInt(index++, groupInfo.getPrivateChat());
             statement.setInt(index++, groupInfo.getSearchable());
+            statement.setInt(index++, groupInfo.getDeleted());
             statement.setLong(index++, groupInfo.getMemberUpdateDt() == 0 ? System.currentTimeMillis() : groupInfo.getUpdateDt());
 
             statement.setString(index++, groupInfo.getName());
@@ -1467,6 +1507,7 @@ public class DatabaseStore {
             statement.setInt(index++, groupInfo.getJoinType());
             statement.setInt(index++, groupInfo.getPrivateChat());
             statement.setInt(index++, groupInfo.getSearchable());
+            statement.setInt(index++, groupInfo.getDeleted());
             statement.setLong(index++, groupInfo.getMemberUpdateDt() == 0 ? System.currentTimeMillis() : groupInfo.getUpdateDt());
             int count = statement.executeUpdate();
             LOG.info("Update rows {}", count);
@@ -2183,6 +2224,7 @@ public class DatabaseStore {
                 ", `_join_type`" +
                 ", `_private_chat`" +
                 ", `_searchable`" +
+                ", _deleted" +
                 " from t_group  where `_gid` = ?";
 
             statement = connection.prepareStatement(sql);
@@ -2239,6 +2281,9 @@ public class DatabaseStore {
                 intValue = rs.getInt(index++);
                 builder.setSearchable(intValue);
 
+                intValue = rs.getInt(index++);
+                builder.setDeleted(intValue);
+
                 return builder.build();
             }
         } catch (SQLException e) {
@@ -2917,6 +2962,99 @@ public class DatabaseStore {
         return null;
     }
 
+    List<WFCMessage.User> getUserInfosByEmail(String email) {
+        Connection connection = null;
+        PreparedStatement statement = null;
+        ResultSet rs = null;
+        List<WFCMessage.User> outList = new ArrayList<>();
+        try {
+            connection = DBUtil.getConnection();
+            String sql = "select `_uid`, `_name`" +
+                ", `_display_name`" +
+                ", `_portrait`" +
+                ", `_mobile`" +
+                ", `_gender`" +
+                ", `_email`" +
+                ", `_address`" +
+                ", `_company`" +
+                ", `_social`" +
+                ", `_extra`" +
+                ", `_type`" +
+                ", `_deleted`" +
+                ", `_dt` from t_user where `_deleted` = 0 and `_email` = ?";
+            statement = connection.prepareStatement(sql);
+            statement.setString(1, email);
+
+            rs = statement.executeQuery();
+            while (rs.next()) {
+                WFCMessage.User.Builder builder = WFCMessage.User.newBuilder();
+                int index = 1;
+                String value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setUid(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setName(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setDisplayName(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setPortrait(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setMobile(value);
+
+                int gender = rs.getInt(index++);
+                builder.setGender(gender);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setEmail(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setAddress(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setCompany(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setSocial(value);
+
+                value = rs.getString(index++);
+                value = (value == null ? "" : value);
+                builder.setExtra(value);
+
+                int type = rs.getInt(index++);
+                builder.setType(type);
+
+                int deleted = rs.getInt(index++);
+                builder.setDeleted(deleted);
+
+                long longValue = rs.getLong(index++);
+                if(longValue <= 0)
+                    longValue = 1;
+                builder.setUpdateDt(longValue);
+
+                outList.add(builder.build());
+            }
+        } catch (SQLException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+            Utility.printExecption(LOG, e, RDBS_Exception);
+        } finally {
+            DBUtil.closeDB(connection, statement, rs);
+        }
+        return outList;
+    }
+
     List<WFCMessage.User> getAllUsers(int count, int offset) {
         Connection connection = null;
         PreparedStatement statement = null;
@@ -3317,8 +3455,12 @@ public class DatabaseStore {
         PreparedStatement statement = null;
         try {
             connection = DBUtil.getConnection();
-            String sql = "delete from t_group where _gid = ?";
-
+            String sql;
+            if(keepGroupInfo) {
+                sql = "update t_group set _deleted = 1, _dt = _dt+1, _member_count = 0, _member_dt = _member_dt+1 where _gid = ?";
+            } else {
+                sql = "delete from t_group where _gid = ?";
+            }
 
             statement = connection.prepareStatement(sql);
             int index = 1;
@@ -3650,7 +3792,11 @@ public class DatabaseStore {
                 sql += " where `_name` = ?";
             }
 
-            sql += " and _status = 0";
+            sql += " and _status <> 64";
+            sql += " and _status <> 16";
+            sql += " and _status <> 17";
+            sql += " and _status <> 24";
+            sql += " and _status <> 25";
 
             sql += " limit 20";
 

broker/src/main/java/io/moquette/persistence/MemoryMessagesStore.java

@@ -24,6 +24,7 @@ import com.google.protobuf.ByteString;
 import com.hazelcast.core.*;
 import com.hazelcast.util.StringUtil;
 import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.action.Action;
 import com.xiaoleilu.loServer.action.admin.AdminAction;
 import com.xiaoleilu.loServer.model.FriendData;
 import cn.wildfirechat.common.ErrorCode;
@@ -49,11 +50,13 @@ import java.net.URL;
 import java.nio.charset.StandardCharsets;
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.function.BiFunction;
 import java.util.function.Consumer;
 
 import static cn.wildfirechat.common.IMExceptionEvent.EventType.EVENT_CALLBACK_Exception;
@@ -73,6 +76,7 @@ import static io.moquette.BrokerConstants.*;
 import static io.moquette.server.Constants.MAX_CHATROOM_MESSAGE_QUEUE;
 import static io.moquette.server.Constants.MAX_MESSAGE_QUEUE;
 import static cn.wildfirechat.pojos.MyInfoType.*;
+import static win.liyufan.im.UserSettingScope.kUserSettingAddFriendStrategy;
 import static win.liyufan.im.UserSettingScope.kUserSettingPCOnline;
 
 public class MemoryMessagesStore implements IMessagesStore {
@@ -152,16 +156,22 @@ public class MemoryMessagesStore implements IMessagesStore {
     private long mFriendRequestDuration = 7 * 24 * 60 * 60 * 1000;
     private long mFriendRejectDuration = 30 * 24 * 60 * 60 * 1000;
     private long mFriendRequestExpiration = 7 * 24 * 60 * 60 * 1000;
+    private RateLimiter mFriendRateLimiter;
     private boolean mFriendRobotAutoAccept = true;
 
     private long mPushExpiredTimes = 604800000L;
+    private Set<Integer> mForcePushTypes = new HashSet<>();
 
     private boolean mMultiPlatformNotification = false;
     private boolean mMobileDefaultSilentWhenPCOnline = true;
     private boolean mDisableStrangerChat = false;
     private Set<String> mAllowStrangerChatSet = new HashSet<>();
+    private Set<Integer> mAllowStrangerLineSet = new HashSet<>();
     private boolean mDisableStrangerAddGroup = false;
+    private boolean mGroupAllowPartSuccess = false;
 
+    private boolean mIDUseUUID = true;
+    private boolean mSensitiveOnlyMessage = true;
     private Set<String> mClientSignatureSet = new HashSet<>();
     private boolean mRejectEmptySignature = true;
 
@@ -197,8 +207,18 @@ public class MemoryMessagesStore implements IMessagesStore {
     private boolean mBroadcastTargetFromUserTable = false;
 
     private boolean mForwardMessageWithClientInfo = false;
+    private boolean mForwardMessageWithSenderInfo = false;
+    private boolean mForwardMessageWithTargetInfo = false;
+
     private boolean mRobotCallbackWithClientInfo = false;
+    private boolean mRobotCallbackWithSenderInfo = false;
+    private boolean mRobotCallbackWithTargetInfo = false;
+    private boolean mRobotMentionExternalRobot = false;
+
     private boolean mChannelCallbackWithClientInfo = false;
+    private boolean mChannelCallbackWithSenderInfo = false;
+    private boolean mChannelCallbackWithTargetInfo = false;
+    private boolean mChannelNewCallbackFeature = true;
 
     private Set<Integer> mUserHideProperties = new HashSet<>();
 
@@ -257,6 +277,32 @@ public class MemoryMessagesStore implements IMessagesStore {
             e.printStackTrace();
         }
 
+        try {
+            String allowStrangerList = m_Server.getConfig().getProperty(BrokerConstants.MESSAGE_Allow_Stranger_Line);
+            if(!StringUtil.isNullOrEmptyAfterTrim(allowStrangerList)) {
+                allowStrangerList = allowStrangerList.replace("，", ",");
+                for (String s : allowStrangerList.split(",")) {
+                    mAllowStrangerLineSet.add(Integer.parseInt(s.trim()));
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        try {
+            String forcePushTypes = m_Server.getConfig().getProperty(BrokerConstants.MESSAGE_Force_Push_Types);
+            if(!StringUtil.isNullOrEmptyAfterTrim(forcePushTypes)) {
+                forcePushTypes = forcePushTypes.replace("，", ",");
+                for (String s : forcePushTypes.split(",")) {
+                    int type = Integer.parseInt(s.trim());
+                    if(type > 0) {
+                        mForcePushTypes.add(type);
+                    }
+                }
+            }
+        } catch (Exception e) {
+        }
+
         try {
             mMultiPlatformNotification = Boolean.parseBoolean(m_Server.getConfig().getProperty(BrokerConstants.SERVER_MULTI_PLATFROM_NOTIFICATION, "false"));
         } catch (Exception e) {
@@ -323,6 +369,13 @@ public class MemoryMessagesStore implements IMessagesStore {
             printMissConfigLog(FRIEND_Request_Expiration_Duration, mFriendRequestExpiration + "");
         }
 
+        try {
+            int friendRequestRateLimit = Integer.parseInt(m_Server.getConfig().getProperty(FRIEND_Request_Rate_Limit, "0"));
+            if(friendRequestRateLimit > 0) {
+                mFriendRateLimiter = new RateLimiter(86400, friendRequestRateLimit);
+            }
+        } catch (Exception e) {
+        }
 
         try {
             mFriendRobotAutoAccept = Boolean.parseBoolean(m_Server.getConfig().getProperty(BrokerConstants.FRIEND_Request_Robot_Auto_Accept, "true"));
@@ -566,9 +619,13 @@ public class MemoryMessagesStore implements IMessagesStore {
 
         try {
             mForwardMessageWithClientInfo = Boolean.parseBoolean(server.getConfig().getProperty(BrokerConstants.MESSAGE_Forward_With_Client_Info, "false"));
-        } catch (Exception e) {
-
-        }
+        } catch (Exception e) {}
+        try {
+            mForwardMessageWithSenderInfo = Boolean.parseBoolean(server.getConfig().getProperty(BrokerConstants.MESSAGE_Forward_With_Sender_Info, "false"));
+        } catch (Exception e) {}
+        try {
+            mForwardMessageWithTargetInfo = Boolean.parseBoolean(server.getConfig().getProperty(BrokerConstants.MESSAGE_Forward_With_Target_Info, "false"));
+        } catch (Exception e) {}
 
         try {
             mBroadcastTargetFromUserTable = Boolean.parseBoolean(server.getConfig().getProperty(BrokerConstants.BROADCAST_Target_From_User_Table, "false"));
@@ -577,20 +634,52 @@ public class MemoryMessagesStore implements IMessagesStore {
         }
 
         try {
-            mRobotCallbackWithClientInfo = Boolean.parseBoolean(server.getConfig().getProperty(BrokerConstants.ROBOT_Callback_With_Client_Info, "false"));
+            mGroupAllowPartSuccess = "true".equals(server.getConfig().getProperty(BrokerConstants.GROUP_ADD_MEMBER_ALLOW_PART_SUCCESS, "false"));
         } catch (Exception e) {
-
         }
+
+        try {
+            mRobotCallbackWithClientInfo = Boolean.parseBoolean(server.getConfig().getProperty(BrokerConstants.ROBOT_Callback_With_Client_Info, "false"));
+        } catch (Exception e) {}
+        try {
+            mRobotCallbackWithSenderInfo = Boolean.parseBoolean(server.getConfig().getProperty(BrokerConstants.ROBOT_Callback_With_Sender_Info, "false"));
+        } catch (Exception e) {}
+        try {
+            mRobotCallbackWithTargetInfo = Boolean.parseBoolean(server.getConfig().getProperty(BrokerConstants.ROBOT_Callback_With_Target_Info, "false"));
+        } catch (Exception e) {}
+        try {
+            mRobotMentionExternalRobot = Boolean.parseBoolean(server.getConfig().getProperty(BrokerConstants.ROBOT_Mention_External_Robot, "false"));
+        } catch (Exception e) {}
+
         try {
             mChannelCallbackWithClientInfo = Boolean.parseBoolean(server.getConfig().getProperty(BrokerConstants.CHANNEL_Callback_With_Client_Info, "false"));
-        } catch (Exception e) {
+        } catch (Exception e) {}
+        try {
+            mChannelCallbackWithSenderInfo = Boolean.parseBoolean(server.getConfig().getProperty(BrokerConstants.CHANNEL_Callback_With_Sender_Info, "false"));
+        } catch (Exception e) {}
+        try {
+            mChannelCallbackWithTargetInfo = Boolean.parseBoolean(server.getConfig().getProperty(BrokerConstants.CHANNEL_Callback_With_Target_Info, "false"));
+        } catch (Exception e) {}
+
+        try {
+            mChannelNewCallbackFeature = Boolean.parseBoolean(server.getConfig().getProperty(BrokerConstants.CHANNEL_New_Callback_Feature, "true"));
+        } catch (Exception e) {}
 
-        }
         try {
             mRecallForwardUrl = server.getConfig().getProperty(BrokerConstants.MESSAGE_RecallMsg_Forward_Url);
         } catch (Exception e) {
 
         }
+
+        try {
+            mIDUseUUID = Boolean.parseBoolean(server.getConfig().getProperty(BrokerConstants.ID_USE_UUID, "false"));
+        } catch (Exception e) {
+        }
+
+        try {
+            mSensitiveOnlyMessage = Boolean.parseBoolean(server.getConfig().getProperty(BrokerConstants.SENSITIVE_Only_Message, "true"));
+        } catch (Exception e) {
+        }
     }
 
     private void printMissConfigLog(String config, String defaultValue) {
@@ -657,13 +746,34 @@ public class MemoryMessagesStore implements IMessagesStore {
         int pullType = ProtoConstants.PullType.Pull_Normal;
 
         if (type == ProtoConstants.ConversationType.ConversationType_Private) {
-            notifyReceivers.add(fromUser);
-            if(message.getToCount() > 0) {
-                if(message.getToList().contains(message.getConversation().getTarget())) {
-                    notifyReceivers.add(message.getConversation().getTarget());
+            if(mRobotMentionExternalRobot && message.getConversation().getTarget().contains("|")) {
+                String[] ss = message.getConversation().getTarget().split("\\|");
+                notifyReceivers.add(ss[0]);
+                notifyReceivers.add(ss[1]);
+                if(!message.getToList().isEmpty()) {
+                    notifyReceivers.addAll(message.getToList());
+                } else if(!StringUtil.isNullOrEmpty(message.getToUser())) {
+                    notifyReceivers.add(message.getToUser());
                 }
             } else {
-                notifyReceivers.add(message.getConversation().getTarget());
+                notifyReceivers.add(fromUser);
+                if (message.getToCount() > 0) {
+                    if (message.getToList().contains(message.getConversation().getTarget())) {
+                        notifyReceivers.add(message.getConversation().getTarget());
+                    }
+                } else {
+                    notifyReceivers.add(message.getConversation().getTarget());
+                }
+            }
+            if (mRobotMentionExternalRobot && message.getContent().getMentionedTargetCount() > 0) {
+                for (String mentioned : message.getContent().getMentionedTargetList()) {
+                    if (!notifyReceivers.contains(mentioned)) {
+                        WFCMessage.User user = getUserInfo(mentioned);
+                        if(user != null && user.getType() == ProtoConstants.UserType.UserType_Robot) {
+                            notifyReceivers.add(mentioned);
+                        }
+                    }
+                }
             }
             pullType = ProtoConstants.PullType.Pull_Normal;
         } else if (type == ProtoConstants.ConversationType.ConversationType_Group) {
@@ -693,9 +803,19 @@ public class MemoryMessagesStore implements IMessagesStore {
                     }
                 }
             }
+            if (mRobotMentionExternalRobot && message.getContent().getMentionedTargetCount() > 0) {
+                for (String mentioned : message.getContent().getMentionedTargetList()) {
+                    if (!notifyReceivers.contains(mentioned)) {
+                        WFCMessage.User user = getUserInfo(mentioned);
+                        if(user != null && user.getType() == ProtoConstants.UserType.UserType_Robot) {
+                            notifyReceivers.add(mentioned);
+                        }
+                    }
+                }
+            }
             pullType = ProtoConstants.PullType.Pull_Normal;
         } else if (type == ProtoConstants.ConversationType.ConversationType_ChatRoom) {
-            boolean isDirect = !StringUtil.isNullOrEmpty(message.getToUser());
+            boolean isDirect = !StringUtil.isNullOrEmpty(message.getToUser()) || !message.getToList().isEmpty();
             Collection<UserClientEntry> entries = getChatroomMembers(message.getConversation().getTarget());
             for (UserClientEntry entry : entries) {
                 if (isDirect) {
@@ -703,6 +823,9 @@ public class MemoryMessagesStore implements IMessagesStore {
                         notifyReceivers.add(message.getToUser());
                         break;
                     }
+                    if (message.getToList().contains(entry.userId)) {
+                        notifyReceivers.add(entry.userId);
+                    }
                 } else {
                     notifyReceivers.add(entry.userId);
                 }
@@ -714,7 +837,7 @@ public class MemoryMessagesStore implements IMessagesStore {
             if (channelInfo != null) {
                 if (channelInfo.getOwner().equals(fromUser)) {
                     if(requestSourceType == ProtoConstants.RequestSourceType.Request_From_Channel
-                        && channelInfo.getAutomatic() != 0) {
+                        && channelInfo.getAutomatic() != 0 && !isChannelNewCallbackFeature()) {
                         LOG.info("Channel api message not send to the owner when automatic");
                     } else {
                         notifyReceivers.add(fromUser);
@@ -744,7 +867,7 @@ public class MemoryMessagesStore implements IMessagesStore {
                     }
                 } else {
                     notifyReceivers.add(fromUser);
-                    if (channelInfo.getAutomatic() == 0) {
+                    if (channelInfo.getAutomatic() == 0 || isChannelNewCallbackFeature()) {
                         notifyReceivers.add(channelInfo.getOwner());
                     } else {
                         LOG.info("Channel api message not send to the owner when automatic");
@@ -762,6 +885,18 @@ public class MemoryMessagesStore implements IMessagesStore {
         return pullType;
     }
 
+    private final Map<String, Integer> unreceivedMsgCount = new ConcurrentHashMap<>();
+
+    @Override
+    public void increaseUnreceivedMsgCount(String user) {
+        unreceivedMsgCount.compute(user, (s, integer) -> integer == null ? 1 : integer+1);
+    }
+
+    @Override
+    public int getUnreceivedMsgCount(String user) {
+        return unreceivedMsgCount.getOrDefault(user, 0);
+    }
+
     @Override
     public Set<String> getAllEnds() {
         return databaseStore.getAllEnds(mBroadcastTargetFromUserTable);
@@ -776,7 +911,7 @@ public class MemoryMessagesStore implements IMessagesStore {
         MemorySessionStore.Session session = m_Server.getStore().sessionsStore().getSession(exceptClientId);
         session.refreshLastActiveTime();
         if (pullType != ProtoConstants.PullType.Pull_ChatRoom) {
-            session.setUnReceivedMsgs(0);
+            unreceivedMsgCount.put(user, 0);
         } else {
             session.refreshLastChatroomActiveTime();
         }
@@ -846,11 +981,13 @@ public class MemoryMessagesStore implements IMessagesStore {
                 session.setPullHistoryMsg(true);
             }
 
+            long previousCurrent;
             while (true) {
                 Map.Entry<Long, Long> entry = maps.higherEntry(current);
                 if (entry == null) {
                     break;
                 }
+                previousCurrent = current;
                 current = entry.getKey();
                 long targetMessageId = entry.getValue();
 
@@ -879,6 +1016,8 @@ public class MemoryMessagesStore implements IMessagesStore {
                         if (size >= 512 * 1024) { //3M
                             if(builder.getMessageCount() == 0){
                                 builder.addMessage(bundle.getMessage());
+                            } else {
+                                current = previousCurrent;
                             }
                             break;
                         }
@@ -1202,7 +1341,7 @@ public class MemoryMessagesStore implements IMessagesStore {
     }
 
     @Override
-    public ErrorCode canAddGroupMembers(String fromUser, List<WFCMessage.GroupMember> memberList) {
+    public ErrorCode canAddGroupMembers(String fromUser, List<WFCMessage.GroupMember> memberList, Map<String, Integer> failedMembers) {
         HazelcastInstance hzInstance = m_Server.getHazelcastInstance();
         MultiMap<String, FriendData> friendsMap = hzInstance.getMultiMap(USER_FRIENDS);
         IMap<String, WFCMessage.User> mUserMap = hzInstance.getMap(USERS);
@@ -1228,7 +1367,12 @@ public class MemoryMessagesStore implements IMessagesStore {
                 for (FriendData friendData : friendDatas) {
                     if (friendData.getFriendUid().equals(fromUser)) {
                         if (friendData.getBlacked() == 1) {
-                            return ErrorCode.ERROR_CODE_IN_BLACK_LIST;
+                            LOG.error("Add group member failure, because inviter {} is blocked by invitee {}", fromUser, targetUser);
+                            if(isGroupAllowPartSuccess()) {
+                                failedMembers.put(targetUser, 1); //black
+                            } else {
+                                return ErrorCode.ERROR_CODE_IN_BLACK_LIST;
+                            }
                         } else {
                             if (friendData.getState() == 0) {
                                 allow = true;
@@ -1252,7 +1396,11 @@ public class MemoryMessagesStore implements IMessagesStore {
                     continue;
                 }
 
-                return ErrorCode.ERROR_CODE_NOT_RIGHT;
+                if(isGroupAllowPartSuccess()) {
+                    failedMembers.put(targetUser, 2);//stranger
+                } else {
+                    return ErrorCode.ERROR_CODE_NOT_RIGHT;
+                }
             }
         } else {
             for (WFCMessage.GroupMember groupMember : memberList) {
@@ -1269,7 +1417,12 @@ public class MemoryMessagesStore implements IMessagesStore {
                 for (FriendData friendData : friendDatas) {
                     if (friendData.getFriendUid().equals(fromUser)) {
                         if (friendData.getBlacked() == 1) {
-                            return ErrorCode.ERROR_CODE_IN_BLACK_LIST;
+                            LOG.error("Add group member failure, because inviter {} is blocked by invitee {}", fromUser, targetUser);
+                            if(isGroupAllowPartSuccess()) {
+                                failedMembers.put(targetUser, 1); //black
+                            } else {
+                                return ErrorCode.ERROR_CODE_IN_BLACK_LIST;
+                            }
                         } else {
                             break;
                         }
@@ -1281,7 +1434,7 @@ public class MemoryMessagesStore implements IMessagesStore {
     }
 
     @Override
-    public WFCMessage.GroupInfo createGroup(String fromUser, WFCMessage.GroupInfo groupInfo, List<WFCMessage.GroupMember> memberList, String memberExtra, boolean isAdmin) {
+    public WFCMessage.GroupInfo createGroup(String fromUser, WFCMessage.GroupInfo groupInfo, List<WFCMessage.GroupMember> memberList, String memberExtra, boolean isAdmin, Map<String, Integer> failedMembers) {
         HazelcastInstance hzInstance = m_Server.getHazelcastInstance();
         IMap<String, WFCMessage.GroupInfo> mIMap = hzInstance.getMap(GROUPS_MAP);
 
@@ -1303,6 +1456,9 @@ public class MemoryMessagesStore implements IMessagesStore {
         List<WFCMessage.GroupMember> updatedMemberList = new ArrayList<>();
         boolean hasOwnerMember = false;
         for (WFCMessage.GroupMember member : memberList) {
+            if(failedMembers.containsKey(member.getMemberId())) {
+                continue;
+            }
             WFCMessage.GroupMember.Builder builder = member.toBuilder();
             builder.setUpdateDt(dt).setCreateDt(dt);
             if (member.getMemberId().equals(owner)) {
@@ -1368,7 +1524,7 @@ public class MemoryMessagesStore implements IMessagesStore {
             event.type = type;
             PojoGroupInfo pojoGroupInfo = new PojoGroupInfo();
             event.groupInfo = pojoGroupInfo;
-            if (groupInfo != null) {
+            if (groupInfo != null && groupInfo.getDeleted() == 0) {
                 pojoGroupInfo.setExtra(groupInfo.getExtra());
                 pojoGroupInfo.setName(groupInfo.getName());
                 pojoGroupInfo.setOwner(groupInfo.getOwner());
@@ -1497,7 +1653,7 @@ public class MemoryMessagesStore implements IMessagesStore {
     }
 
     @Override
-    public ErrorCode addGroupMembers(String operator, boolean isAdmin, String groupId, List<WFCMessage.GroupMember> memberList, String extra) {
+    public ErrorCode addGroupMembers(String operator, boolean isAdmin, String groupId, List<WFCMessage.GroupMember> memberList, String extra, Map<String, Integer> failedMembers) {
         HazelcastInstance hzInstance = m_Server.getHazelcastInstance();
         IMap<String, WFCMessage.GroupInfo> mIMap = hzInstance.getMap(GROUPS_MAP);
 
@@ -1570,6 +1726,10 @@ public class MemoryMessagesStore implements IMessagesStore {
         List<WFCMessage.GroupMember> tmp = new ArrayList<>();
         int newMemberCount = 0;
         for (WFCMessage.GroupMember member : memberList) {
+            if(failedMembers.containsKey(member.getMemberId())) {
+                continue;
+            }
+
             if (existMemberIds.contains(member.getMemberId()) && member.getType() != GroupMemberType_Removed) {
                 if(!isAdmin)
                     continue;
@@ -1602,7 +1762,11 @@ public class MemoryMessagesStore implements IMessagesStore {
 
         if (memberList.size() == 0) {
             if (!isAdmin) {
-                return ErrorCode.ERROR_CODE_ALREADY_IN_GROUP;
+                if(failedMembers.isEmpty()) {
+                    return ErrorCode.ERROR_CODE_ALREADY_IN_GROUP;
+                } else {
+                    return ErrorCode.ERROR_CODE_SUCCESS;
+                }
             } else {
                 return ErrorCode.ERROR_CODE_SUCCESS;
             }
@@ -1621,6 +1785,10 @@ public class MemoryMessagesStore implements IMessagesStore {
 
         List<String> memberIds = new ArrayList<>();
         for (WFCMessage.GroupMember member : memberList) {
+            if(failedMembers.containsKey(member.getMemberId())) {
+                continue;
+            }
+
             if (member.getType() != GroupMemberType_Removed) {
                 memberIds.add(member.getMemberId());
             }
@@ -1702,8 +1870,19 @@ public class MemoryMessagesStore implements IMessagesStore {
             WFCMessage.GroupMember newOwner = null;
             for (WFCMessage.GroupMember member :members) {
                 if (!member.getMemberId().equals(operator) && member.getType() != GroupMemberType_Removed) {
-                    newOwner = member;
-                    break;
+                    if(newOwner == null) {
+                        newOwner = member;
+                    } else {
+                        if(newOwner.getType() == GroupMemberType_Silent && member.getType() != GroupMemberType_Silent) {
+                            newOwner = member;
+                        } else if(newOwner.getType() != GroupMemberType_Manager && member.getType() == GroupMemberType_Manager) {
+                            newOwner = member;
+                        } else if(newOwner.getType() == member.getType()) {
+                            if(newOwner.getCreateDt() > member.getCreateDt() && member.getCreateDt() > 0) {
+                                newOwner = member;
+                            }
+                        }
+                    }
                 }
             }
 
@@ -1835,6 +2014,19 @@ public class MemoryMessagesStore implements IMessagesStore {
                 if (!isAllow) {
                     return ErrorCode.ERROR_CODE_NOT_RIGHT;
                 }
+
+                if (modifyType == Modify_Group_Name && !StringUtil.isNullOrEmpty(value)) {
+                    if(!mSensitiveOnlyMessage) {
+                        Set<String> matched = handleSensitiveWord(value);
+                        if (matched != null && !matched.isEmpty()) {
+                            return ErrorCode.ERROR_CODE_SENSITIVE_MATCHED;
+                        }
+                    }
+
+                    if(!isAllowName(value)) {
+                        return ErrorCode.ERROR_CODE_NOT_RIGHT;
+                    }
+                }
             }
 
             if (oldInfo.getType() == ProtoConstants.GroupType.GroupType_Normal) {
@@ -1872,6 +2064,14 @@ public class MemoryMessagesStore implements IMessagesStore {
             newInfoBuilder.setPrivateChat(Integer.parseInt(value));
         else if(modifyType == Modify_Group_Searchable)
             newInfoBuilder.setSearchable(Integer.parseInt(value));
+        else if(modifyType == Modify_Group_Type) {
+            int newType = Integer.parseInt(value);
+            if(newType < 0 || newType > ProtoConstants.GroupType.GroupType_Organization) {
+                LOG.error("modify group type failure, invalid group type {}", newType);
+                return ErrorCode.INVALID_PARAMETER;
+            }
+            newInfoBuilder.setType(newType);
+        }
         else
             return ErrorCode.INVALID_PARAMETER;
 
@@ -1900,7 +2100,7 @@ public class MemoryMessagesStore implements IMessagesStore {
         WFCMessage.GroupInfo groupInfo = mIMap.get(groupId);
         if (groupInfo == null) {
             groupInfo = databaseStore.getPersistGroupInfo(groupId);
-            if (groupInfo != null) {
+            if (groupInfo != null && groupInfo.getDeleted() == 0) {
                 mIMap.set(groupId, groupInfo);
             } else {
                 return ErrorCode.ERROR_CODE_NOT_EXIST;
@@ -1985,7 +2185,7 @@ public class MemoryMessagesStore implements IMessagesStore {
         WFCMessage.GroupInfo groupInfo = mIMap.get(groupId);
         if (groupInfo == null) {
             groupInfo = databaseStore.getPersistGroupInfo(groupId);
-            if (groupInfo != null) {
+            if (groupInfo != null && groupInfo.getDeleted() == 0) {
                 mIMap.set(groupId, groupInfo);
             } else {
                 return ErrorCode.ERROR_CODE_NOT_EXIST;
@@ -2069,16 +2269,12 @@ public class MemoryMessagesStore implements IMessagesStore {
         ArrayList<WFCMessage.GroupInfo> out = new ArrayList<>();
         for (WFCMessage.UserRequest request : requests) {
             WFCMessage.GroupInfo groupInfo = mIMap.get(request.getUid());
-            if (groupInfo == null) {
-                groupInfo = databaseStore.getPersistGroupInfo(request.getUid());
-                if (groupInfo != null) {
-                    mIMap.set(request.getUid(), groupInfo);
-                }
-            }
-
             if (groupInfo != null && groupInfo.getUpdateDt() > request.getUpdateDt()) {
-                if(!isAdmin && !StringUtil.isNullOrEmpty(fromUser)) {
+                if(!isAdmin && !StringUtil.isNullOrEmpty(fromUser) && groupInfo.getDeleted() == 0) {
                     WFCMessage.GroupMember gm = getGroupMember(groupInfo.getTargetId(), fromUser);
+                    if((gm == null || gm.getType() == GroupMemberType_Removed) && request.getUpdateDt() > 0) {
+                        continue;
+                    }
                     if(gm == null) {
                         groupInfo = groupInfo.toBuilder().setMemberUpdateDt(-1).build();
                     } else if(gm.getType() == GroupMemberType_Removed) {
@@ -2205,15 +2401,29 @@ public class MemoryMessagesStore implements IMessagesStore {
         }
 
         //check the new owner is in member list? is that necessary?
-        long updateDt = System.currentTimeMillis();
-        groupInfo = groupInfo.toBuilder().setOwner(newOwner).setUpdateDt(updateDt).setMemberUpdateDt(updateDt).build();
-        mIMap.set(groupId, groupInfo);
-
         MultiMap<String, WFCMessage.GroupMember> groupMembers = hzInstance.getMultiMap(GROUP_MEMBERS);
         Collection<WFCMessage.GroupMember> members = groupMembers.get(groupId);
         if (members == null || members.size() == 0) {
             members = loadGroupMemberFromDB(hzInstance, groupId);
         }
+
+        boolean isNewOwnerInGroup = false;
+        for (WFCMessage.GroupMember member : members) {
+            if (member.getMemberId().equals(newOwner)) {
+                if(member.getType() != GroupMemberType_Removed) {
+                    isNewOwnerInGroup = true;
+                }
+                break;
+            }
+        }
+        if(!isNewOwnerInGroup) {
+            return ErrorCode.ERROR_CODE_NOT_IN_GROUP;
+        }
+
+        long updateDt = System.currentTimeMillis();
+        groupInfo = groupInfo.toBuilder().setOwner(newOwner).setUpdateDt(updateDt).setMemberUpdateDt(updateDt).build();
+        mIMap.set(groupId, groupInfo);
+
         int modifyMemeberCount = 0;
         for (WFCMessage.GroupMember member : members) {
             if (modifyMemeberCount == 2) {
@@ -2306,7 +2516,7 @@ public class MemoryMessagesStore implements IMessagesStore {
         IMap<String, WFCMessage.GroupInfo> groups = hzInstance.getMap(GROUPS_MAP);
         WFCMessage.GroupInfo groupInfo = groups.get(groupId);
         boolean isMute = false;
-        if (groupInfo != null) {
+        if (groupInfo != null && groupInfo.getDeleted() == 0) {
             if (groupInfo.getOwner().equals(memberId)) {
                 return ErrorCode.ERROR_CODE_SUCCESS;
             }
@@ -2379,7 +2589,7 @@ public class MemoryMessagesStore implements IMessagesStore {
             }
             boolean isExpired = false;
             if (!canRecall && message.getFromUser().equals(operatorId)) {
-                if (now - message.getServerTimestamp() > mRecallTimeLimit * 1000) {
+                if (mRecallTimeLimit >= 0 && now - message.getServerTimestamp() > mRecallTimeLimit * 1000) {
                     isExpired = true;
                 } else {
                     canRecall = true;
@@ -2391,7 +2601,8 @@ public class MemoryMessagesStore implements IMessagesStore {
 
                 WFCMessage.GroupInfo groupInfo = groupMap.get(message.getConversation().getTarget());
                 if (groupInfo == null) {
-                    return ErrorCode.ERROR_CODE_RECALL_TIME_EXPIRED;
+                    LOG.info("recall message failure, group {} not exist", message.getConversation().getTarget());
+                    return ErrorCode.ERROR_CODE_NOT_EXIST;
                 }
                 if (operatorId.equals(groupInfo.getOwner())) {
                     if(operatorId.equals(message.getFromUser())) {
@@ -2652,6 +2863,19 @@ public class MemoryMessagesStore implements IMessagesStore {
             ) {
             switch (entry.getType()) {
                 case Modify_DisplayName:
+                    if(!StringUtil.isNullOrEmpty(entry.getValue())) {
+                        if (!mSensitiveOnlyMessage) {
+                            Set<String> matched = handleSensitiveWord(entry.getValue());
+                            if (matched != null && !matched.isEmpty()) {
+                                return ErrorCode.ERROR_CODE_SENSITIVE_MATCHED;
+                            }
+                        }
+
+                        if(!isAllowName(entry.getValue())) {
+                            return ErrorCode.ERROR_CODE_NOT_RIGHT;
+                        }
+                    }
+
                     builder.setDisplayName(entry.getValue());
                     modified = true;
                     break;
@@ -2828,7 +3052,9 @@ public class MemoryMessagesStore implements IMessagesStore {
         IMap<String, Integer> mUserMap = hzInstance.getMap(USER_STATUS);
         ArrayList<InputOutputUserBlockStatus> out = new ArrayList<>();
         for (Map.Entry<String, Integer> entry : mUserMap.entrySet()) {
-            out.add(new InputOutputUserBlockStatus(entry.getKey(), entry.getValue()));
+            if(entry.getValue() > 0) {
+                out.add(new InputOutputUserBlockStatus(entry.getKey(), entry.getValue()));
+            }
         }
         return out;
     }
@@ -2986,13 +3212,18 @@ public class MemoryMessagesStore implements IMessagesStore {
         return getUserInfo(userId);
     }
 
+    @Override
+    public List<WFCMessage.User> getUserInfosByEmail(String email) {
+        return databaseStore.getUserInfosByEmail(email);
+    }
+
     @Override
     public List<WFCMessage.User> getUserInfoList(int count, int offset) {
         return databaseStore.getAllUsers(count, offset);
     }
 
     @Override
-    public List<WFCMessage.User> searchUser(String keyword, int searchType, int page) {
+    public List<WFCMessage.User> searchUser(String keyword, int searchType, int userType, int page) {
         if (mDisableSearch) {
             return new ArrayList<>();
         }
@@ -3013,7 +3244,7 @@ public class MemoryMessagesStore implements IMessagesStore {
             return new ArrayList<>();
         }
 
-        return databaseStore.searchUserFromDB(keyword, searchType, page);
+        return databaseStore.searchUserFromDB(keyword, searchType, userType, page);
     }
 
     @Override
@@ -3140,7 +3371,7 @@ public class MemoryMessagesStore implements IMessagesStore {
     }
 
     @Override
-    public ErrorCode isAllowUserMessage(String targetUser, String fromUser) {
+    public ErrorCode isAllowUserMessage(String targetUser, String fromUser, int line) {
         HazelcastInstance hzInstance = m_Server.getHazelcastInstance();
         MultiMap<String, FriendData> friendsMap = hzInstance.getMultiMap(USER_FRIENDS);
 
@@ -3167,7 +3398,7 @@ public class MemoryMessagesStore implements IMessagesStore {
 
         if (mDisableStrangerChat) {
             //在禁止私聊时，是否是允许私聊的用户id
-            if(mAllowStrangerChatSet.contains(targetUser) || mAllowStrangerChatSet.contains(fromUser)) {
+            if(mAllowStrangerChatSet.contains(targetUser) || mAllowStrangerChatSet.contains(fromUser) || mAllowStrangerLineSet.contains(line)) {
                 return ErrorCode.ERROR_CODE_SUCCESS;
             }
 
@@ -3191,6 +3422,30 @@ public class MemoryMessagesStore implements IMessagesStore {
         return ErrorCode.ERROR_CODE_SUCCESS;
     }
 
+    @Override
+    public ErrorCode isBlacked(String fromUser, String userId) {
+        HazelcastInstance hzInstance = m_Server.getHazelcastInstance();
+        MultiMap<String, FriendData> friendsMap = hzInstance.getMultiMap(USER_FRIENDS);
+
+        Collection<FriendData> friendDatas = friendsMap.get(fromUser);
+
+        if (friendDatas == null || friendDatas.size() == 0) {
+            friendDatas = loadFriend(friendsMap, fromUser);
+        }
+
+        for (FriendData friendData : friendDatas) {
+            if (friendData.getFriendUid().equals(userId)) {
+                if (friendData.getBlacked() == 1) {
+                    return ErrorCode.ERROR_CODE_IN_BLACK_LIST;
+                } else {
+                    break;
+                }
+            }
+        }
+
+        return ErrorCode.ERROR_CODE_SUCCESS;
+    }
+
     synchronized Collection<FriendData> loadFriend(MultiMap<String, FriendData> friendsMap, String userId) {
         Collection<FriendData> friends = databaseStore.getPersistFriends(userId);
         if (friends != null) {
@@ -3308,13 +3563,29 @@ public class MemoryMessagesStore implements IMessagesStore {
     }
 
     @Override
-    public ErrorCode saveAddFriendRequest(String userId, WFCMessage.AddFriendRequest request, long[] head, boolean isAdmin) {
+    public ErrorCode saveAddFriendRequest(String userId, WFCMessage.AddFriendRequest request, long[] head, boolean isAdmin, boolean isRobot) {
         if (!isAdmin && mDisableFriendRequest) {
             return ErrorCode.ERROR_CODE_NOT_RIGHT;
         }
 
+        if(!isRobot && !isAdmin && mFriendRateLimiter != null) {
+            if(!mFriendRateLimiter.isGranted(userId)) {
+                LOG.error("User {} request add friend over frequency", userId);
+                return ErrorCode.ERROR_CODE_OVER_FREQUENCY;
+            }
+        }
+
         HazelcastInstance hzInstance = m_Server.getHazelcastInstance();
         MultiMap<String, WFCMessage.FriendRequest> requestMap = hzInstance.getMultiMap(USER_FRIENDS_REQUEST);
+
+        WFCMessage.UserSettingEntry userSettingData = getUserSetting(request.getTargetUid(), kUserSettingAddFriendStrategy, "");
+        boolean noVerify = userSettingData != null && "1".equals(userSettingData.getValue());
+        boolean noAllow = userSettingData != null && "2".equals(userSettingData.getValue());
+
+        if(noAllow) {
+            return ErrorCode.ERROR_CODE_NOT_RIGHT;
+        }
+
         Collection<WFCMessage.FriendRequest> requests = requestMap.get(userId);
         if (requests == null || requests.size() == 0) {
             requests = loadFriendRequest(requestMap, userId);
@@ -3329,7 +3600,7 @@ public class MemoryMessagesStore implements IMessagesStore {
             }
         }
 
-        if (existRequest != null && existRequest.getStatus() != ProtoConstants.FriendRequestStatus.RequestStatus_Accepted && !isAdmin) {
+        if (!noVerify && existRequest != null && existRequest.getStatus() != ProtoConstants.FriendRequestStatus.RequestStatus_Accepted && !isAdmin) {
             if (existRequest.getStatus() == ProtoConstants.FriendRequestStatus.RequestStatus_Rejected
                 && System.currentTimeMillis() - existRequest.getUpdateDt() < mFriendRejectDuration) {
                 return ErrorCode.ERROR_CODE_FRIEND_REQUEST_BLOCKED;
@@ -3371,7 +3642,7 @@ public class MemoryMessagesStore implements IMessagesStore {
             .setReason(request.getReason())
             .setExtra(request.getExtra())
             .setStatus(ProtoConstants.FriendRequestStatus.RequestStatus_Sent)
-            .setToReadStatus(false)
+            .setToReadStatus(noVerify)
             .setUpdateDt(System.currentTimeMillis())
             .build();
 
@@ -3379,6 +3650,12 @@ public class MemoryMessagesStore implements IMessagesStore {
         requestMap.remove(userId);
         requestMap.remove(request.getTargetUid());
 
+
+        if(noVerify) {
+            WFCMessage.HandleFriendRequest handleFriendRequest = WFCMessage.HandleFriendRequest.newBuilder().setTargetUid(userId).setStatus(ProtoConstants.FriendRequestStatus.RequestStatus_Accepted).build();
+            ServerAPIHelper.sendRequest(request.getTargetUid(), null, IMTopic.HandleFriendRequestTopic, handleFriendRequest.toByteArray(), null, ProtoConstants.RequestSourceType.Request_From_User);
+        }
+
         head[0] = newRequest.getUpdateDt();
         return ErrorCode.ERROR_CODE_SUCCESS;
     }
@@ -3690,6 +3967,25 @@ public class MemoryMessagesStore implements IMessagesStore {
         return ErrorCode.ERROR_CODE_SUCCESS;
     }
 
+    @Override
+    public boolean isAllowName(String name) {
+        if(StringUtil.isNullOrEmpty(name)) {
+            return true;
+        }
+
+        name = name.trim();
+        SystemSettingPojo notAllowNameSetting = getSystemSetting(ProtoConstants.SystemSettingType.NOT_ALLOW_USER_NAMES);
+        if (notAllowNameSetting != null && !StringUtil.isNullOrEmpty(notAllowNameSetting.value)) {
+            String[] ss = notAllowNameSetting.value.split(",");
+            for (String s : ss) {
+                if(name.contains(s.trim())) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
     @Override
     public ErrorCode handleJoinChatroom(String userId, String clientId, String chatroomId) {
         IMap<String, WFCMessage.ChatroomInfo> chatroomInfoMap = m_Server.getHazelcastInstance().getMap(CHATROOMS);
@@ -4329,7 +4625,7 @@ public class MemoryMessagesStore implements IMessagesStore {
         } else if(modifyType == Modify_Channel_Menu) {
             OutputGetChannelInfo.OutputMenuList outputMenuButtons = GsonUtil.gson.fromJson(value, OutputGetChannelInfo.OutputMenuList.class);
             if (!outputMenuButtons.isEmpty()) {
-                for (OutputGetChannelInfo.OutputMenu outputMenuButton : outputMenuButtons) {
+                for (PojoChannelMenu outputMenuButton : outputMenuButtons) {
                     newInfoBuilder.addMenu(outputMenuButton.toPbInfo());
                 }
             }
@@ -4559,6 +4855,11 @@ public class MemoryMessagesStore implements IMessagesStore {
         return new ArrayList<>(databaseStore.getSensitiveWord());
     }
 
+    @Override
+    public boolean isSensitiveOnlyMessage() {
+        return mSensitiveOnlyMessage;
+    }
+
     @Override
     public WFCMessage.Message getMessage(long messageId) {
         HazelcastInstance hzInstance = m_Server.getHazelcastInstance();
@@ -4585,6 +4886,11 @@ public class MemoryMessagesStore implements IMessagesStore {
         return mGroupVisibleQuitKickoffNotification;
     }
 
+    @Override
+    public boolean isGroupAllowPartSuccess() {
+        return mGroupAllowPartSuccess;
+    }
+
     @Override
     public int getGroupForbiddenClientOperation() {
         return mGroupForbiddenClientOperation;
@@ -4595,16 +4901,56 @@ public class MemoryMessagesStore implements IMessagesStore {
         return mForwardMessageWithClientInfo;
     }
 
+    @Override
+    public boolean isForwardMessageWithSenderInfo() {
+        return mForwardMessageWithSenderInfo;
+    }
+
+    @Override
+    public boolean isForwardMessageWithTargetInfo() {
+        return mForwardMessageWithTargetInfo;
+    }
+
     @Override
     public boolean isRobotCallbackWithClientInfo() {
         return mRobotCallbackWithClientInfo;
     }
 
+    @Override
+    public boolean isRobotCallbackWithSenderInfo() {
+        return mRobotCallbackWithSenderInfo;
+    }
+
+    @Override
+    public boolean isRobotCallbackWithTargetInfo() {
+        return mRobotCallbackWithTargetInfo;
+    }
+
+    @Override
+    public boolean isRobotMentionExternalRobot() {
+        return mRobotMentionExternalRobot;
+    }
+
     @Override
     public boolean isChannelCallbackWithClientInfo() {
         return mChannelCallbackWithClientInfo;
     }
 
+    @Override
+    public boolean isChannelCallbackWithSenderInfo() {
+        return mChannelCallbackWithSenderInfo;
+    }
+
+    @Override
+    public boolean isChannelCallbackWithTargetInfo() {
+        return mChannelCallbackWithTargetInfo;
+    }
+
+    @Override
+    public boolean isChannelNewCallbackFeature() {
+        return mChannelNewCallbackFeature;
+    }
+
     @Override
     public boolean isRobotAutoAcceptFriendRequest() {
         return mFriendRobotAutoAccept;
@@ -4615,6 +4961,11 @@ public class MemoryMessagesStore implements IMessagesStore {
         return mPushExpiredTimes;
     }
 
+    @Override
+    public Set<Integer> getForcePushTypes() {
+        return mForcePushTypes;
+    }
+
     @Override
     public List<Integer> getClientForbiddenSendTypes() {
         return mForbiddenClientSendTypes;
@@ -4733,9 +5084,11 @@ public class MemoryMessagesStore implements IMessagesStore {
 
     @Override
     public String getShortUUID(){
-        int id = databaseStore.getGeneratedId();
-        if (id > 0) {
-            return IDUtils.toUid(id);
+        if(!mIDUseUUID) {
+            int id = databaseStore.getGeneratedId();
+            if (id > 0) {
+                return IDUtils.toUid(id);
+            }
         }
         return UUIDGenerator.getUUID();
     }

broker/src/main/java/io/moquette/persistence/MemorySessionStore.java

@@ -92,10 +92,6 @@ public class MemorySessionStore implements ISessionsStore {
             return unReceivedMsgs;
         }
 
-        public void setUnReceivedMsgs(int unReceivedMsgs) {
-            this.unReceivedMsgs = unReceivedMsgs;
-        }
-
         public int getPushType() {
             return pushType;
         }

broker/src/main/java/io/moquette/server/Server.java

@@ -140,7 +140,7 @@ public class Server {
         Runtime.getRuntime().addShutdownHook(new Thread(instance::stopServer));
         Runtime.getRuntime().addShutdownHook(new Thread(httpServer::shutdown));
 
-        System.out.println("Wildfire IM server start success...");
+        System.out.println("Wildfire IM server start success.");
     }
 
     /**

broker/src/main/java/io/moquette/server/netty/NettyAcceptor.java

@@ -135,7 +135,6 @@ public class NettyAcceptor implements ServerAcceptor {
                         }
                     }
                 })
-            .option(ChannelOption.SO_BACKLOG, 10240) // 服务端可连接队列大小
             .option(ChannelOption.SO_BACKLOG, nettySoBacklog)
             .option(ChannelOption.SO_REUSEADDR, nettySoReuseaddr)
             .childOption(ChannelOption.TCP_NODELAY, nettyTcpNodelay)

broker/src/main/java/io/moquette/spi/IMessagesStore.java

@@ -102,9 +102,9 @@ public interface IMessagesStore {
     WFCMessage.PullMessageResult fetchMessage(String user, String exceptClientId, long fromMessageId, int pullType);
     WFCMessage.PullMessageResult loadRemoteMessages(String user, WFCMessage.Conversation conversation, long beforeUid, int count, Collection<Integer> contentTypes);
     long insertUserMessages(String sender, int conversationType, String target, int line, int messageContentType, String userId, long messageId, boolean directing);
-    ErrorCode canAddGroupMembers(String operator, List<WFCMessage.GroupMember> memberList);
-    WFCMessage.GroupInfo createGroup(String operator, WFCMessage.GroupInfo groupInfo, List<WFCMessage.GroupMember> memberList, String memberExtra, boolean isAdmin);
-    ErrorCode addGroupMembers(String operator, boolean isAdmin, String groupId, List<WFCMessage.GroupMember> memberList, String extra);
+    ErrorCode canAddGroupMembers(String operator, List<WFCMessage.GroupMember> memberList, Map<String, Integer> failedMembers);
+    WFCMessage.GroupInfo createGroup(String operator, WFCMessage.GroupInfo groupInfo, List<WFCMessage.GroupMember> memberList, String memberExtra, boolean isAdmin, Map<String, Integer> failedMembers);
+    ErrorCode addGroupMembers(String operator, boolean isAdmin, String groupId, List<WFCMessage.GroupMember> memberList, String extra, Map<String, Integer> failedMembers);
     ErrorCode kickoffGroupMembers(String operator, boolean isAdmin, String groupId, List<String> memberList);
     ErrorCode quitGroup(String operator, String groupId, boolean admin);
     void clearUserGroups(String userId);
@@ -153,7 +153,8 @@ public interface IMessagesStore {
     WFCMessage.User getUserInfo(String userId);
     WFCMessage.User getUserInfoByName(String name);
     WFCMessage.User getUserInfoByMobile(String mobile);
-    List<WFCMessage.User> searchUser(String keyword, int searchType, int page);
+    List<WFCMessage.User> getUserInfosByEmail(String email);
+    List<WFCMessage.User> searchUser(String keyword, int searchType, int userType, int page);
 
     List<WFCMessage.User> getUserInfoList(int count, int offset);
 
@@ -178,16 +179,19 @@ public interface IMessagesStore {
     void clearUserFriend(String userId);
     List<WFCMessage.FriendRequest> getFriendRequestList(String userId, long version);
 
-    ErrorCode saveAddFriendRequest(String userId, WFCMessage.AddFriendRequest request, long[] head, boolean isAdmin);
+    ErrorCode saveAddFriendRequest(String userId, WFCMessage.AddFriendRequest request, long[] head, boolean isAdmin, boolean isRobot);
     ErrorCode handleFriendRequest(String userId, WFCMessage.HandleFriendRequest request, WFCMessage.Message.Builder msgBuilder, long[] heads, boolean isAdmin);
     ErrorCode deleteFriend(String userId, String friendUid, long[] head);
     ErrorCode blackUserRequest(String fromUser, String targetUserId, int status, long[] head);
     FriendData getFriendData(String fromUser, String targetUserId);
     ErrorCode SyncFriendRequestUnread(String userId, long unreadDt, long[] head);
-    ErrorCode isAllowUserMessage(String fromUser, String userId);
+    ErrorCode isAllowUserMessage(String fromUser, String userId, int line);
+    ErrorCode isBlacked(String fromUser, String userId);
     ErrorCode setFriendAliasRequest(String fromUser, String targetUserId, String alias, long[] head);
     ErrorCode setFriendExtraRequest(String fromUser, String targetUserId, String extra, long[] head);
 
+    boolean isAllowName(String name);
+
     ErrorCode handleJoinChatroom(String userId, String clientId, String chatroomId);
     ErrorCode handleQuitChatroom(String userId, String clientId, String chatroomId);
 
@@ -230,9 +234,13 @@ public interface IMessagesStore {
     boolean addSensitiveWords(List<String> words);
     boolean removeSensitiveWords(List<String> words);
     List<String> getAllSensitiveWords();
+    boolean isSensitiveOnlyMessage();
 
     WFCMessage.Message getMessage(long messageId);
 
+    void increaseUnreceivedMsgCount(String user);
+    int getUnreceivedMsgCount(String user);
+
     boolean isAllowClientCustomGroupNotification();
     boolean isAllowRobotCustomGroupNotification();
     int getVisibleQuitKickoffNotification();
@@ -240,12 +248,23 @@ public interface IMessagesStore {
     int getGroupForbiddenClientOperation();
 
     boolean isForwardMessageWithClientInfo();
-    boolean isRobotCallbackWithClientInfo();
-    boolean isChannelCallbackWithClientInfo();
+    boolean isForwardMessageWithSenderInfo();
+    boolean isForwardMessageWithTargetInfo();
 
+    boolean isRobotCallbackWithClientInfo();
+    boolean isRobotCallbackWithSenderInfo();
+    boolean isRobotCallbackWithTargetInfo();
+    boolean isRobotMentionExternalRobot();
+
+    boolean isChannelCallbackWithClientInfo();
+    boolean isChannelCallbackWithSenderInfo();
+    boolean isChannelCallbackWithTargetInfo();
+    boolean isChannelNewCallbackFeature();
+    boolean isGroupAllowPartSuccess();
     boolean isRobotAutoAcceptFriendRequest();
 
     long getPushExpiredTimes();
+    Set<Integer> getForcePushTypes();
 
     List<Integer> getClientForbiddenSendTypes();
     List<Integer> getBlackListExceptionTypes();

broker/src/main/java/io/moquette/spi/impl/MessagesPublisher.java

@@ -16,15 +16,13 @@
 
 package io.moquette.spi.impl;
 
-import cn.wildfirechat.pojos.OutputClient;
-import cn.wildfirechat.pojos.OutputMessageData;
+import org.json.simple.JSONObject;
+import cn.wildfirechat.pojos.*;
 import cn.wildfirechat.proto.ProtoConstants;
 import cn.wildfirechat.proto.WFCMessage;
 import cn.wildfirechat.push.PushServer;
-import com.google.gson.Gson;
 import com.hazelcast.core.HazelcastInstance;
 import com.hazelcast.util.StringUtil;
-import cn.wildfirechat.pojos.OutputNotifyChannelSubscribeStatus;
 import com.xiaoleilu.loServer.model.FriendData;
 import io.moquette.persistence.*;
 import io.moquette.persistence.MemorySessionStore.Session;
@@ -35,12 +33,14 @@ import io.moquette.spi.ISessionsStore;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.handler.codec.mqtt.*;
+import org.json.simple.parser.JSONParser;
 import win.liyufan.im.*;
 
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.nio.charset.StandardCharsets;
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
@@ -48,6 +48,7 @@ import java.util.concurrent.Executors;
 import java.util.function.BiFunction;
 
 import static cn.wildfirechat.common.IMExceptionEvent.EventType.EVENT_CALLBACK_Exception;
+import static cn.wildfirechat.proto.ProtoConstants.ConversationType.*;
 import static cn.wildfirechat.proto.ProtoConstants.PersistFlag.Transparent;
 
 public class MessagesPublisher {
@@ -158,7 +159,7 @@ public class MessagesPublisher {
         }
     }
 
-    private void publish2Receivers(String sender, int conversationType, String target, int line, long messageId, Collection<String> receivers, String pushContent, String pushData, String exceptClientId, int pullType, int messageContentType, long serverTime, int mentionType, List<String> mentionTargets, int persistFlag, boolean directing) {
+    private void publish2Receivers(String sender, int conversationType, String target, int line, long messageId, Collection<String> receivers, String pushContent, String pushData, long callStartUid, String exceptClientId, int pullType, int messageContentType, long serverTime, int mentionType, List<String> mentionTargets, int persistFlag, boolean directing) {
         if (persistFlag == Transparent) {
             publishTransparentMessage2Receivers(messageId, receivers, pullType, exceptClientId);
             return;
@@ -177,19 +178,10 @@ public class MessagesPublisher {
                         if (message == null) {
                             message = m_messagesStore.getMessage(messageId);
                         }
-                        OutputClient outputClient = null;
-                        if(m_messagesStore.isRobotCallbackWithClientInfo() && !StringUtil.isNullOrEmpty(exceptClientId)) {
-                            Session session = m_sessionsStore.getSession(exceptClientId);
-                            if(session != null && session.getUsername().equals(sender)) {
-                                outputClient = new OutputClient(session.getPlatform(), exceptClientId);
-                            }
-                        }
-
-                        final WFCMessage.Message finalMsg = message;
-                        OutputClient finalOutputClient = outputClient;
+                        OutputMessageData outputMessageData = getOutputMessageWithExtraInfo(message, exceptClientId, m_messagesStore.isRobotCallbackWithClientInfo() , m_messagesStore.isRobotCallbackWithSenderInfo(), m_messagesStore.isRobotCallbackWithTargetInfo());
                         Server.getServer().getCallbackScheduler().execute(() -> {
                             try {
-                                HttpUtils.httpJsonPost(robot.getCallback(), GsonUtil.gson.toJson(OutputMessageData.fromProtoMessage(finalMsg, finalOutputClient), OutputMessageData.class), HttpUtils.HttpPostType.POST_TYPE_Robot_Message_Callback);
+                                HttpUtils.httpJsonPost(robot.getCallback(), GsonUtil.gson.toJson(outputMessageData, OutputMessageData.class), HttpUtils.HttpPostType.POST_TYPE_Robot_Message_Callback);
                             } catch (Exception e) {
                                 e.printStackTrace();
                                 Utility.printExecption(LOG, e, EVENT_CALLBACK_Exception);
@@ -271,6 +263,7 @@ public class MessagesPublisher {
                 boolean isVoipSilent;
                 boolean isNoDisturb;
                 boolean isConvSilent = false;
+                boolean isForcePush = false;
                 if (pullType == ProtoConstants.PullType.Pull_ChatRoom) {
                     isSilent = true;
                     isConvSilent = true;
@@ -283,12 +276,17 @@ public class MessagesPublisher {
 
                     if (!user.equals(sender)) {
                         WFCMessage.Conversation conversation;
-                        if (conversationType == ProtoConstants.ConversationType.ConversationType_Private) {
+                        if (conversationType == ConversationType_Private) {
                             conversation = WFCMessage.Conversation.newBuilder().setType(conversationType).setLine(line).setTarget(sender).build();
                         } else {
                             conversation = WFCMessage.Conversation.newBuilder().setType(conversationType).setLine(line).setTarget(target).build();
                         }
 
+                        if(m_messagesStore.getForcePushTypes().contains(messageContentType)) {
+                           LOG.info("The message type {} force push", messageContentType);
+                            isForcePush = true;
+                        }
+
                         if (m_messagesStore.getUserConversationSilent(user, conversation)) {
                             LOG.info("The conversation {}-{}-{} is slient", conversation.getType(), conversation.getTarget(), conversation.getLine());
                             isConvSilent = true;
@@ -317,7 +315,7 @@ public class MessagesPublisher {
 
                     if (!StringUtil.isNullOrEmpty(pushContent) || messageContentType == 400) {
                         if (!isConvSilent && (persistFlag & 0x02) > 0) {
-                            targetSession.setUnReceivedMsgs(targetSession.getUnReceivedMsgs() + 1);
+                            m_messagesStore.increaseUnreceivedMsgCount(user);
                         }
                     }
                 }
@@ -369,17 +367,17 @@ public class MessagesPublisher {
                         continue;
                     }
 
-                    if (isConvSilent && !isVoip) {
+                    if (isConvSilent && !isVoip && !isForcePush) {
                         LOG.info("Silent of user or conversation");
                         continue;
                     }
 
-                    if (isSilent && !isVoip) {
+                    if (isSilent && !isVoip && !isForcePush) {
                         LOG.info("Silent of user");
                         continue;
                     }
 
-                    if(isVoip && isVoipSilent) {
+                    if(isVoip && isVoipSilent && !isForcePush) {
                         LOG.info("voip silent of user");
                         continue;
                     }
@@ -393,7 +391,7 @@ public class MessagesPublisher {
 
                     if(!sendNameLoaded) {
                         List<String> list = new ArrayList<>();
-                        senderName = getUserDisplayName(sender, conversationType == ProtoConstants.ConversationType.ConversationType_Group ? target : null, list);
+                        senderName = getUserDisplayName(sender, conversationType == ConversationType_Group ? target : null, list);
                         if(!list.isEmpty()) {
                             senderPortrait = list.get(0);
                         }
@@ -416,13 +414,25 @@ public class MessagesPublisher {
                             name = fd.getAlias();
                         }
                     }
-                    this.messageSender.sendPush(sender, conversationType, target, line, messageId, targetSession.getClientID(), pushContent, pushData, messageContentType, serverTime, name, senderPortrait, targetName, targetPortrait, targetSession.getUnReceivedMsgs(), curMentionType, isHiddenDetail, targetSession.getLanguage());
+
+                    this.messageSender.sendPush(sender, conversationType, target, line, messageId, targetSession.getClientID(), pushContent, pushData, callStartUid, messageContentType, serverTime, name, senderPortrait, targetName, targetPortrait, m_messagesStore.getUnreceivedMsgCount(user), curMentionType, isHiddenDetail, targetSession.getLanguage(), getExistBadgeNumber(user));
                 }
 
             }
         }
     }
-    
+
+    private int getExistBadgeNumber(String user) {
+        int existBadgeNumber = 0;
+        WFCMessage.UserSettingEntry userSettingData = m_messagesStore.getUserSetting(user, UserSettingScope.kUserSettingScopeSyncBadge, "");
+        if(userSettingData != null && !StringUtil.isNullOrEmpty(userSettingData.getValue())) {
+            try {
+                existBadgeNumber = Integer.parseInt(userSettingData.getValue());
+            } catch (NumberFormatException e) {}
+        }
+        return existBadgeNumber;
+    }
+
     public boolean sendOfflineNotify(String clientId) {
         boolean targetIsActive = this.connectionDescriptors.isConnected(clientId);
         if (targetIsActive) {
@@ -446,6 +456,7 @@ public class MessagesPublisher {
         WFCMessage.Message message = m_messagesStore.getMessage(messageHead);
 
         if (message != null) {
+            message = message.toBuilder().setMessageId(0).build();
             for (String user : receivers) {
                 Collection<Session> sessions = m_sessionsStore.sessionForUser(user);
 
@@ -480,19 +491,10 @@ public class MessagesPublisher {
                     if (userInfo != null && userInfo.getType() == ProtoConstants.UserType.UserType_Robot) {
                         WFCMessage.Robot robot = m_messagesStore.getRobot(user);
                         if (robot != null && !StringUtil.isNullOrEmpty(robot.getCallback())) {
-                            OutputClient outputClient = null;
-                            if(m_messagesStore.isRobotCallbackWithClientInfo() && !StringUtil.isNullOrEmpty(exceptClientId)) {
-                                Session session = m_sessionsStore.getSession(exceptClientId);
-                                if(session != null && session.getUsername().equals(message.getFromUser())) {
-                                    outputClient = new OutputClient(session.getPlatform(), exceptClientId);
-                                }
-                            }
-
-                            final WFCMessage.Message finalMsg = message;
-                            OutputClient finalOutputClient = outputClient;
+                            OutputMessageData outputMessageData = getOutputMessageWithExtraInfo(message, exceptClientId, m_messagesStore.isRobotCallbackWithClientInfo() , m_messagesStore.isRobotCallbackWithSenderInfo(), m_messagesStore.isRobotCallbackWithTargetInfo());
                             Server.getServer().getCallbackScheduler().execute(() -> {
                                 try {
-                                    HttpUtils.httpJsonPost(robot.getCallback(), GsonUtil.gson.toJson(OutputMessageData.fromProtoMessage(finalMsg, finalOutputClient), OutputMessageData.class), HttpUtils.HttpPostType.POST_TYPE_Robot_Message_Callback);
+                                    HttpUtils.httpJsonPost(robot.getCallback(), GsonUtil.gson.toJson(outputMessageData, OutputMessageData.class), HttpUtils.HttpPostType.POST_TYPE_Robot_Message_Callback);
                                 } catch (Exception e) {
                                     e.printStackTrace();
                                     Utility.printExecption(LOG, e, EVENT_CALLBACK_Exception);
@@ -524,9 +526,9 @@ public class MessagesPublisher {
     }
 
     String getTargetName(String targetId, int cnvType, String fromUser, List<String> portraitList) {
-        if (cnvType == ProtoConstants.ConversationType.ConversationType_Private) {
+        if (cnvType == ConversationType_Private) {
             return getUserDisplayName(targetId, null, portraitList);
-        } else if(cnvType == ProtoConstants.ConversationType.ConversationType_Group) {
+        } else if(cnvType == ConversationType_Group) {
             WFCMessage.GroupInfo group = m_messagesStore.getGroupInfo(targetId);
             if(group != null) {
                 if(!StringUtil.isNullOrEmpty(group.getPortrait())) {
@@ -539,7 +541,7 @@ public class MessagesPublisher {
                 }
                 return group.getName();
             }
-        } else if(cnvType == ProtoConstants.ConversationType.ConversationType_Channel) {
+        } else if(cnvType == ConversationType_Channel) {
             WFCMessage.ChannelInfo channelInfo = m_messagesStore.getChannelInfo(targetId);
             if (channelInfo != null) {
                 if(!StringUtil.isNullOrEmpty(channelInfo.getPortrait())) {
@@ -596,7 +598,7 @@ public class MessagesPublisher {
                 }
 
                 if (IMTopic.NotifyFriendRequestTopic.equals(topic)) {
-                    messageSender.sendPush(fromUser, receiver, targetSession.getClientID(), pushContent, PushServer.PushMessageType.PUSH_MESSAGE_TYPE_FRIEND_REQUEST, System.currentTimeMillis(), fromUserName, targetSession.getUnReceivedMsgs() + 1, targetSession.getLanguage());
+                    messageSender.sendPush(fromUser, receiver, targetSession.getClientID(), pushContent, PushServer.PushMessageType.PUSH_MESSAGE_TYPE_FRIEND_REQUEST, System.currentTimeMillis(), fromUserName, m_messagesStore.getUnreceivedMsgCount(receiver) + 1, targetSession.getLanguage(), getExistBadgeNumber(receiver));
                 }
             }
         }
@@ -661,21 +663,21 @@ public class MessagesPublisher {
     }
 
     public void publish2Receivers(WFCMessage.Message message, Set<String> receivers, String exceptClientId, int pullType) {
-        if (message.getConversation().getType() == ProtoConstants.ConversationType.ConversationType_Channel) {
+        if (message.getConversation().getType() == ConversationType_Channel) {
             WFCMessage.ChannelInfo channelInfo = m_messagesStore.getChannelInfo(message.getConversation().getTarget());
-            if (channelInfo != null && !StringUtil.isNullOrEmpty(channelInfo.getCallback()) && channelInfo.getAutomatic() == 1 && !message.getFromUser().equals(channelInfo.getOwner())) {
-                OutputClient outputClient = null;
-                if(m_messagesStore.isChannelCallbackWithClientInfo() && !StringUtil.isNullOrEmpty(exceptClientId)) {
-                    Session session = m_sessionsStore.getSession(exceptClientId);
-                    if(session != null && session.getUsername().equals(message.getFromUser())) {
-                        outputClient = new OutputClient(session.getPlatform(), exceptClientId);
-                    }
-                }
 
-                OutputClient finalOutputClient = outputClient;
+            boolean forwardMsg;
+            if(m_messagesStore.isChannelNewCallbackFeature()) {
+                forwardMsg = channelInfo != null && !StringUtil.isNullOrEmpty(channelInfo.getCallback()) && !StringUtil.isNullOrEmpty(exceptClientId);
+            } else {
+                forwardMsg = channelInfo != null && !StringUtil.isNullOrEmpty(channelInfo.getCallback()) && channelInfo.getAutomatic() == 1 && !message.getFromUser().equals(channelInfo.getOwner());
+            }
+
+            if (forwardMsg) {
+                OutputMessageData outputMessageData = getOutputMessageWithExtraInfo(message, exceptClientId, m_messagesStore.isChannelCallbackWithClientInfo() , m_messagesStore.isChannelCallbackWithSenderInfo(), m_messagesStore.isChannelCallbackWithTargetInfo());
                 Server.getServer().getCallbackScheduler().execute(() -> {
                     try {
-                        HttpUtils.httpJsonPost(channelInfo.getCallback() + "/message", GsonUtil.gson.toJson(OutputMessageData.fromProtoMessage(message, finalOutputClient), OutputMessageData.class), HttpUtils.HttpPostType.POST_TYPE_Channel_Message_Callback);
+                        HttpUtils.httpJsonPost(channelInfo.getCallback() + "/message", GsonUtil.gson.toJson(outputMessageData, OutputMessageData.class), HttpUtils.HttpPostType.POST_TYPE_Channel_Message_Callback);
                     } catch (Exception e) {
                         e.printStackTrace();
                         Utility.printExecption(LOG, e, EVENT_CALLBACK_Exception);
@@ -719,18 +721,92 @@ public class MessagesPublisher {
             pushContent = null;
         }
 
+        long callStartUid = 0;
+        if (message.getContent().getType() == 402) {
+            try {
+                String str = new String(message.getContent().getData().toByteArray(), StandardCharsets.UTF_8);
+                JSONObject jsonObject = (JSONObject)(new JSONParser().parse(str));
+                if (jsonObject.containsKey("u")) {
+                    callStartUid = (Long)jsonObject.get("u");
+                }
+            } catch (Exception e) {}
+        }
+
+
         publish2Receivers(message.getFromUser(),
                     message.getConversation().getType(), message.getConversation().getTarget(), message.getConversation().getLine(),
                     messageId,
                     receivers,
-                    pushContent, message.getContent().getPushData(), exceptClientId, pullType, message.getContent().getType(), message.getServerTimestamp(), message.getContent().getMentionedType(), message.getContent().getMentionedTargetList(), message.getContent().getPersistFlag(), message.hasToUser() || !message.getToList().isEmpty());
+                    pushContent, message.getContent().getPushData(), callStartUid, exceptClientId, pullType, message.getContent().getType(), message.getServerTimestamp(), message.getContent().getMentionedType(), message.getContent().getMentionedTargetList(), message.getContent().getPersistFlag(), message.hasToUser() || !message.getToList().isEmpty());
 
     }
 
-    public void forwardMessage(final WFCMessage.Message message, String forwardUrl, OutputClient outputClient) {
+    private OutputMessageData getOutputMessageWithExtraInfo(WFCMessage.Message message, String clientId, boolean withClient, boolean withSender, boolean withTarget) {
+        if (message == null) {
+            return null;
+        }
+
+        OutputClient outputClient = null;
+        if (withClient && !StringUtil.isNullOrEmpty(clientId)) {
+            Session session = m_sessionsStore.getSession(clientId);
+            if(session != null && session.getUsername().equals(message.getFromUser())) {
+                outputClient = new OutputClient(session.getPlatform(), clientId);
+            }
+        }
+
+        OutputMessageData outputMessageData = OutputMessageData.fromProtoMessage(message, outputClient);
+        if (withSender) {
+            WFCMessage.User senderInfo = m_messagesStore.getUserInfo(message.getFromUser());
+            outputMessageData.setSenderUserInfo(InputOutputUserInfo.fromPbUser(senderInfo));
+        }
+
+        if (withTarget) {
+            if (message.getConversation().getType() == ConversationType_Private) {
+                WFCMessage.User targetInfo = m_messagesStore.getUserInfo(message.getConversation().getTarget());
+                if (targetInfo != null) {
+                    outputMessageData.setTargetUserInfo(InputOutputUserInfo.fromPbUser(targetInfo));
+                }
+            } else if(message.getConversation().getType() == ConversationType_Group) {
+                WFCMessage.GroupInfo groupInfo = m_messagesStore.getGroupInfo(message.getConversation().getTarget());
+                if (groupInfo != null) {
+                    PojoGroupInfo pojoGroupInfo = new PojoGroupInfo();
+                    pojoGroupInfo.setExtra(groupInfo.getExtra());
+                    pojoGroupInfo.setName(groupInfo.getName());
+                    pojoGroupInfo.setOwner(groupInfo.getOwner());
+                    pojoGroupInfo.setPortrait(groupInfo.getPortrait());
+                    pojoGroupInfo.setTarget_id(groupInfo.getTargetId());
+                    pojoGroupInfo.setType(groupInfo.getType());
+                    pojoGroupInfo.setMember_count(groupInfo.getMemberCount());
+                    pojoGroupInfo.setMute(groupInfo.getMute());
+                    pojoGroupInfo.setJoin_type(groupInfo.getJoinType());
+                    pojoGroupInfo.setPrivate_chat(groupInfo.getPrivateChat());
+                    pojoGroupInfo.setSearchable(groupInfo.getSearchable());
+                    pojoGroupInfo.setMax_member_count(groupInfo.getMemberCount());
+                    pojoGroupInfo.setHistory_message(groupInfo.getHistoryMessage());
+                    pojoGroupInfo.setSuper_group(groupInfo.getSuperGroup()>0);
+                    pojoGroupInfo.setDeleted(groupInfo.getDeleted()>0);
+                    pojoGroupInfo.setUpdate_dt(groupInfo.getUpdateDt());
+                    pojoGroupInfo.setMember_update_dt(groupInfo.getMemberUpdateDt());
+                    outputMessageData.setTargetGroupInfo(pojoGroupInfo);
+                }
+            } else if(message.getConversation().getType() == ConversationType_Channel) {
+                WFCMessage.ChannelInfo targetInfo = m_messagesStore.getChannelInfo(message.getConversation().getTarget());
+                if (targetInfo != null) {
+                    outputMessageData.setTargetChannelInfo(OutputGetChannelInfo.fromPbInfo(targetInfo));
+                }
+            }
+        }
+
+        return outputMessageData;
+    }
+
+
+
+    public void forwardMessage(final WFCMessage.Message message, String forwardUrl, String fromClientId) {
+        OutputMessageData outputMessageData = getOutputMessageWithExtraInfo(message, fromClientId, m_messagesStore.isForwardMessageWithClientInfo() , m_messagesStore.isForwardMessageWithSenderInfo(), m_messagesStore.isForwardMessageWithTargetInfo());
         Server.getServer().getCallbackScheduler().execute(() -> {
             try {
-                HttpUtils.httpJsonPost(forwardUrl, GsonUtil.gson.toJson(OutputMessageData.fromProtoMessage(message, outputClient), OutputMessageData.class), HttpUtils.HttpPostType.POST_TYPE_Forward_Message_Callback);
+                HttpUtils.httpJsonPost(forwardUrl, GsonUtil.gson.toJson(outputMessageData), HttpUtils.HttpPostType.POST_TYPE_Forward_Message_Callback);
             } catch (Exception e) {
                 e.printStackTrace();
                 Utility.printExecption(LOG, e, EVENT_CALLBACK_Exception);
@@ -738,9 +814,10 @@ public class MessagesPublisher {
         });
     }
 
-    public void forwardMessageWithCallback(final WFCMessage.Message message, String forwardUrl, HttpUtils.HttpCallback callback) {
+    public void forwardMessageWithCallback(final WFCMessage.Message message, String fromClientId, String forwardUrl, HttpUtils.HttpCallback callback) {
+        OutputMessageData outputMessageData = getOutputMessageWithExtraInfo(message, fromClientId, m_messagesStore.isForwardMessageWithClientInfo() , m_messagesStore.isForwardMessageWithSenderInfo(), m_messagesStore.isForwardMessageWithTargetInfo());
         try {
-            HttpUtils.httpJsonPost(forwardUrl, GsonUtil.gson.toJson(OutputMessageData.fromProtoMessage(message), OutputMessageData.class), new HttpUtils.HttpCallback() {
+            HttpUtils.httpJsonPost(forwardUrl, GsonUtil.gson.toJson(outputMessageData), new HttpUtils.HttpCallback() {
                 @Override
                 public void onSuccess(String content) {
                     Server.getServer().getImBusinessScheduler().execute(()->{
@@ -762,7 +839,10 @@ public class MessagesPublisher {
     }
 
     public void notifyChannelListenStatusChanged(WFCMessage.ChannelInfo channelInfo, String user, boolean listen) {
-        if (channelInfo == null || StringUtil.isNullOrEmpty(channelInfo.getCallback()) || channelInfo.getAutomatic() == 0) {
+        if (channelInfo == null || StringUtil.isNullOrEmpty(channelInfo.getCallback())) {
+            return;
+        }
+        if(!m_messagesStore.isChannelNewCallbackFeature() && channelInfo.getAutomatic() == 0) {
             return;
         }
 

broker/src/main/java/io/moquette/spi/impl/PersistentQueueMessageSender.java

@@ -37,16 +37,18 @@ class PersistentQueueMessageSender {
         this.connectionDescriptorStore = connectionDescriptorStore;
     }
 
-    void sendPush(String sender, int conversationType, String target, int line, long messageId, String deviceId, String pushContent, String pushData, int messageContentType, long serverTime, String senderName, String senderPortrait, String targetName, String targetPortrait, int unReceivedMsg, int mentionType, boolean isHiddenDetail, String language) {
+    void sendPush(String sender, int conversationType, String target, int line, long messageId, String deviceId, String pushContent, String pushData, long callStartUid, int messageContentType, long serverTime, String senderName, String senderPortrait, String targetName, String targetPortrait, int unReceivedMsg, int mentionType, boolean isHiddenDetail, String language, int existBadgeNumber) {
         LOG.info("Send push to {}, message from {}", deviceId, sender);
         PushMessage pushMessage = new PushMessage(sender, conversationType, target, line, messageContentType, serverTime, senderName, senderPortrait, targetName, targetPortrait, unReceivedMsg, mentionType, isHiddenDetail, language);
         pushMessage.pushContent = pushContent;
         pushMessage.pushData = pushData;
         pushMessage.messageId = messageId;
+        pushMessage.callStartUid = callStartUid;
+        pushMessage.existBadgeNumber = existBadgeNumber;
         PushServer.getServer().pushMessage(pushMessage, deviceId, pushContent);
     }
 
-    void sendPush(String sender, String target, String deviceId, String pushContent, int pushContentType, long serverTime, String senderName, int unReceivedMsg, String language) {
+    void sendPush(String sender, String target, String deviceId, String pushContent, int pushContentType, long serverTime, String senderName, int unReceivedMsg, String language, int existBadgeNumber) {
         LOG.info("Send push to {}, message from {}", deviceId, sender);
         PushMessage pushMessage = new PushMessage(sender, target, serverTime, senderName, unReceivedMsg, language, pushContentType);
         pushMessage.pushContent = pushContent;

broker/src/main/java/win/liyufan/im/GitRepositoryState.java

@@ -12,6 +12,7 @@ import io.moquette.server.Server;
 
 import java.io.*;
 import java.util.Properties;
+import java.util.UUID;
 
 public class GitRepositoryState {
     public final String tags;
@@ -28,6 +29,8 @@ public class GitRepositoryState {
     public final String commitMessageFull;
     public final String commitMessageShort;
     public final String commitTime;
+    public static final String globalLabel = UUID.randomUUID().toString();
+    public String label;
     public final String closestTagName;
     public final String closestTagCommitCount;
 
@@ -63,6 +66,7 @@ public class GitRepositoryState {
         this.buildHost = String.valueOf(properties.get("git.build.host"));
         this.buildVersion = String.valueOf(properties.get("git.build.version"));
         this.runTime = Server.getServer().getRunTime();
+        this.label = globalLabel;
     }
 
     public static GitRepositoryState getGitRepositoryState() throws IOException {

broker/src/main/java/win/liyufan/im/HttpUtils.java

@@ -102,7 +102,7 @@ public class HttpUtils {
                     if(httpCallback != null) {
                         int code = response.code();
                         if(code == 200) {
-                            if(response.body() != null && response.body().contentLength() > 0) {
+                            if(response.body() != null) {
                                 httpCallback.onSuccess(response.body().string());
                             } else {
                                 httpCallback.onSuccess(null);

broker/src/main/java/win/liyufan/im/IMTopic.java

@@ -10,6 +10,7 @@ package win.liyufan.im;
 
 public interface IMTopic {
 	String SendMessageTopic = "MS";
+    String RobotReplyMessageTopic = "RRM";
     String MultiCastMessageTopic = "MMC";
     String RecallMessageTopic = "MR";
     String RecallMultiCastMessageTopic = "MRMC";

broker/src/main/java/win/liyufan/im/UserSettingScope.java

@@ -20,4 +20,6 @@ public interface UserSettingScope {
     int kUserSettingPttSilent = 25;
     int kUserSettingGroupRemark = 26;
     int kUserSettingPrivacySearchable = 27;
+    int kUserSettingAddFriendStrategy = 28;
+    int kUserSettingScopeSyncBadge = 29;
 }

common/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>wildfirechat-parent</artifactId>
         <groupId>cn.wildfirechat</groupId>
-        <version>1.2.4</version>
+        <version>1.3.9</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

common/src/main/java/cn/wildfirechat/common/APIPath.java

@@ -17,9 +17,16 @@ public interface APIPath {
     String Sensitive_Del = "/admin/sensitive/del";
     String Sensitive_Query = "/admin/sensitive/query";
 
+    String Create_Domain = "/admin/domain/create";
+    String Get_Domain = "/admin/domain/get";
+    String Destroy_Domain = "/admin/domain/destroy";
+    String List_Domain = "/admin/domain/list";
+    String Ping_Domain = "/admin/domain/ping";
+
     String Create_User = "/admin/user/create";
     String Update_User = "/admin/user/update";
     String Destroy_User = "/admin/user/destroy";
+    String Search_User = "/admin/user/search_user";
     String Create_Robot = "/admin/robot/create";
     String CreateOrUpdate_Device = "/admin/device/create";
     String Get_Device = "/admin/device/get";
@@ -27,6 +34,8 @@ public interface APIPath {
     String User_Get_Token = "/admin/user/get_token";
     String User_Update_Block_Status = "/admin/user/update_block_status";
     String User_Get_Info = "/admin/user/get_info";
+    String User_Batch_Get_Infos = "/admin/user/batch_get_infos";
+    String User_Get_Email_Info = "/admin/user/get_info_by_email";
     String User_Get_All = "/admin/user/all";
     String User_Get_Robot_Info = "/admin/user/get_robot_info";
     String User_Get_Blocked_List = "/admin/user/get_blocked_list";
@@ -51,7 +60,12 @@ public interface APIPath {
     String Friend_Get_Requests = "/admin/friend/get_requests";
     String Relation_Get = "/admin/relation/get";
 
+    String Handle_Friend_Send_Request = "/admin/friend/handle_send_request";
+
+    String Admin_Moments_Post_Feed = "/admin/moments/feed/post";
+
     String Msg_Send = "/admin/message/send";
+    String Msg_Publish = "/admin/message/publish";
     String Msg_Recall = "/admin/message/recall";
     String Msg_Delete = "/admin/message/delete";
     String Msg_Update = "/admin/message/update";
@@ -60,6 +74,8 @@ public interface APIPath {
     String Msg_Multicast = "/admin/message/multicast";
     String Msg_RecallBroadCast = "/admin/message/recall_broadcast";
     String Msg_RecallMultiCast = "/admin/message/recall_multicast";
+    String Msg_DeleteBroadCast = "/admin/message/delete_broadcast";
+    String Msg_DeleteMultiCast = "/admin/message/delete_multicast";
     String Msg_ConvRead = "/admin/message/conv_read";
     String Msg_Delivery = "/admin/message/delivery";
     String Conversation_Delete = "/admin/conversation/delete";
@@ -69,6 +85,7 @@ public interface APIPath {
     String Group_Dismiss = "/admin/group/del";
     String Group_Transfer = "/admin/group/transfer";
     String Group_Get_Info = "/admin/group/get_info";
+    String Group_Batch_Info = "/admin/group/batch_infos";
     String Group_Modify_Info = "/admin/group/modify";
     String Group_Member_List = "/admin/group/member/list";
     String Group_Member_Get = "/admin/group/member/get";
@@ -84,6 +101,10 @@ public interface APIPath {
     String Group_Set_Member_Extra = "/admin/group/member/set_extra";
     String Get_Common_Groups = "/admin/group/common_group";
 
+    String Sync_Group = "/admin/mesh/group_sync";
+    String Conference_User_Request = "/admin/conference/user_request";
+    String Conference_User_Event = "/admin/conference/user_event";
+
     String Create_Channel = "/admin/channel/create";
     String Destroy_Channel = "/admin/channel/destroy";
     String Get_Channel_Info = "/admin/channel/get";
@@ -108,6 +129,8 @@ public interface APIPath {
     String Channel_Update_Profile = "/channel/update_profile";
     String Channel_Get_Profile = "/channel/get_profile";
     String Channel_Message_Send = "/channel/message/send";
+    String Channel_Msg_Recall = "/channel/message/recall";
+    String Channel_Msg_Republish = "/channel/message/republish";
     String Channel_Subscribe = "/channel/subscribe";
     String Channel_Subscriber_List = "/channel/subscriber_list";
     String Channel_Is_Subscriber = "/channel/is_subscriber";
@@ -116,6 +139,7 @@ public interface APIPath {
     String Robot_User_Info = "/robot/user_info";
     String Robot_Get_Profile = "/robot/profile";
     String Robot_Message_Send = "/robot/message/send";
+    String Robot_Message_Reply = "/robot/message/reply";
     String Robot_Message_Recall = "/robot/message/recall";
     String Robot_Message_Update = "/robot/message/update";
     String Robot_Set_Callback = "/robot/set_callback";
@@ -139,5 +163,17 @@ public interface APIPath {
     String Robot_Group_Transfer = "/robot/group/transfer";
     String Robot_Group_Set_Manager = "/robot/group/manager/set";
 
+    String Robot_Moments_Post_Feed = "/robot/moments/feed/post";
+    String Robot_Moments_Pull_Feeds = "/robot/moments/feed/pull";
+    String Robot_Moments_Update_Feed = "/robot/moments/feed/update";
+    String Robot_Moments_Post_Comment = "/robot/moments/comment/post";
+    String Robot_Moments_Pull_Comment = "/robot/moments/comment/pull";
+    String Robot_Moments_Fetch_Feed = "/robot/moments/feed/pull_one";
+    String Robot_Moments_Fetch_Profiles = "/robot/moments/profiles/pull";
+    String Robot_Moments_Recall_Comment = "/robot/moments/comment/recall";
+    String Robot_Moments_Recall_Feed = "/robot/moments/feed/recall";
+    String Robot_Moments_Update_Profiles_List_Value = "/robot/moments/profiles/list/push";
+    String Robot_Moments_Update_Profiles_Value = "/robot/moments/profiles/value/push";
+
     String Robot_Conference_Request = "/robot/conference/request";
 }

common/src/main/java/cn/wildfirechat/common/ErrorCode.java

@@ -49,6 +49,7 @@ public enum ErrorCode {
     ERROR_CODE_ROBOT_NO_TOKEN(27, "robot no token"),
     ERROR_CODE_WS_NOT_CONFIGURED_CORRECTLY(28, "ws not configured correctly"),
     ERROR_CODE_TIME_INCONSISTENT(30, "time inconsistent"),
+    ERROR_CODE_MESSAGE_TOO_LARGE(35, "message too large"),
     ERROR_CODE_CONFERENCE_ROOM_NOT_EXIST(60, "conference room not exist"),
     ERROR_CODE_CONFERENCE_SERVICE_NOT_AVAILABLE(61, "conference service not available"),
 
@@ -65,6 +66,8 @@ public enum ErrorCode {
     ERROR_CODE_CONFERENCE_ERROR(90, "Conference server response error"),
 
     ERROR_CODE_FUNCTION_DISABLED(220, "function disabled"),
+    ERROR_CODE_SERVER_BUSY(221, "Server busy"),
+    ERROR_CODE_PARTLY_SUCCESS(222, "Partly success"),
 
     ERROR_CODE_OTHER_CLIENT_ALREADY_IN_CHATROOM(225, "other client already in chatroom"),
 

common/src/main/java/cn/wildfirechat/messagecontentbuilder/MediaMessageContentBuilder.java

@@ -1,19 +0,0 @@
-package cn.wildfirechat.messagecontentbuilder;
-
-import cn.wildfirechat.pojos.MessagePayload;
-
-abstract public class MediaMessageContentBuilder extends MessageContentBuilder{
-    private String remoteMediaUrl;
-
-    public MediaMessageContentBuilder remoteMediaUrl(String remoteMediaUrl) {
-        this.remoteMediaUrl = remoteMediaUrl;
-        return this;
-    }
-
-    @Override
-    protected MessagePayload encodeBase() {
-        MessagePayload payload = super.encodeBase();
-        payload.setRemoteMediaUrl(remoteMediaUrl);
-        return payload;
-    }
-}

common/src/main/java/cn/wildfirechat/messagecontentbuilder/MessageContentBuilder.java

@@ -1,33 +0,0 @@
-package cn.wildfirechat.messagecontentbuilder;
-
-import cn.wildfirechat.pojos.MessagePayload;
-
-import java.util.List;
-
-public abstract class MessageContentBuilder {
-    private int mentionedType;
-    private List<String> mentionedTargets;
-    private String extra;
-    public MessageContentBuilder mentionedType(int mentionedType) {
-        this.mentionedType = mentionedType;
-        return this;
-    }
-    public MessageContentBuilder mentionedTargets(List<String> mentionedTargets) {
-        this.mentionedTargets = mentionedTargets;
-        return this;
-    }
-
-    public MessageContentBuilder extra(String extra) {
-        this.extra = extra;
-        return this;
-    }
-
-    protected MessagePayload encodeBase() {
-        MessagePayload payload = new MessagePayload();
-        payload.setMentionedType(mentionedType);
-        payload.setMentionedTarget(mentionedTargets);
-        payload.setExtra(extra);
-        return payload;
-    }
-    abstract public MessagePayload build();
-}

common/src/main/java/cn/wildfirechat/messagecontentbuilder/SoundMessageContentBuilder.java

@@ -1,25 +0,0 @@
-package cn.wildfirechat.messagecontentbuilder;
-
-import cn.wildfirechat.pojos.MessagePayload;
-import cn.wildfirechat.proto.ProtoConstants;
-import org.json.simple.JSONObject;
-
-public class SoundMessageContentBuilder extends MediaMessageContentBuilder {
-    private int duration;
-    public static SoundMessageContentBuilder newBuilder(int duration) {
-        SoundMessageContentBuilder builder = new SoundMessageContentBuilder();
-        builder.duration = duration;
-        return builder;
-    }
-    @Override
-    public MessagePayload build() {
-        MessagePayload payload = encodeBase();
-        payload.setType(ProtoConstants.ContentType.Voice);
-        payload.setMediaType(ProtoConstants.MessageMediaType.VOICE);
-        payload.setPersistFlag(ProtoConstants.PersistFlag.Persist_And_Count);
-        JSONObject jsonObject = new JSONObject();
-        jsonObject.put("duration", duration);
-        payload.setContent(jsonObject.toJSONString());
-        return payload;
-    }
-}

common/src/main/java/cn/wildfirechat/messagecontentbuilder/StreamingTextMessageContentBuilder.java

@@ -1,48 +0,0 @@
-package cn.wildfirechat.messagecontentbuilder;
-
-import cn.wildfirechat.pojos.MessagePayload;
-import cn.wildfirechat.proto.ProtoConstants;
-import com.google.gson.Gson;
-
-import java.nio.charset.StandardCharsets;
-import java.util.Base64;
-import java.util.HashMap;
-import java.util.Map;
-
-public class StreamingTextMessageContentBuilder extends MessageContentBuilder{
-    private String text;
-    private String streamId;
-    private boolean generating;
-    public static StreamingTextMessageContentBuilder newBuilder(String streamId) {
-        StreamingTextMessageContentBuilder builder = new StreamingTextMessageContentBuilder();
-        builder.generating = false;
-        builder.streamId = streamId;
-        return builder;
-    }
-    public StreamingTextMessageContentBuilder text(String text) {
-        this.text = text;
-        return this;
-    }
-
-    public StreamingTextMessageContentBuilder generating(boolean generating) {
-        this.generating = generating;
-        return this;
-    }
-
-    @Override
-    public MessagePayload build() {
-        MessagePayload payload = encodeBase();
-        payload.setSearchableContent(text);
-        payload.setContent(streamId);
-        if(generating) {
-            //正在生成消息的类型是14，存储标记位为透传为4。
-            payload.setType(14);
-            payload.setPersistFlag(4);
-        } else {
-            //已经生成消息的类型是15，存储标记位为透传为3。
-            payload.setType(15);
-            payload.setPersistFlag(3);
-        }
-        return payload;
-    }
-}

common/src/main/java/cn/wildfirechat/messagecontentbuilder/TextMessageContentBuilder.java

@@ -1,21 +0,0 @@
-package cn.wildfirechat.messagecontentbuilder;
-
-import cn.wildfirechat.pojos.MessagePayload;
-import cn.wildfirechat.proto.ProtoConstants;
-
-public class TextMessageContentBuilder extends MessageContentBuilder{
-    private String text;
-    public static TextMessageContentBuilder newBuilder(String text) {
-        TextMessageContentBuilder builder = new TextMessageContentBuilder();
-        builder.text = text;
-        return builder;
-    }
-    @Override
-    public MessagePayload build() {
-        MessagePayload payload = encodeBase();
-        payload.setType(ProtoConstants.ContentType.Text);
-        payload.setPersistFlag(ProtoConstants.PersistFlag.Persist_And_Count);
-        payload.setSearchableContent(text);
-        return payload;
-    }
-}

common/src/main/java/cn/wildfirechat/pojos/GetUserSessionResult.java

@@ -1,5 +1,6 @@
 package cn.wildfirechat.pojos;
 
+
 import java.util.ArrayList;
 import java.util.List;
 
@@ -33,3 +34,4 @@ public class GetUserSessionResult {
         userSessions = new ArrayList<>();
     }
 }
+

common/src/main/java/cn/wildfirechat/pojos/GroupNotificationBinaryContent.java

@@ -13,8 +13,10 @@ import cn.wildfirechat.proto.WFCMessage;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.protobuf.ByteString;
+import io.netty.util.internal.StringUtil;
 
 import java.util.List;
+import java.util.Map;
 
 public class GroupNotificationBinaryContent {
     //groupId
@@ -32,6 +34,10 @@ public class GroupNotificationBinaryContent {
     //value2(member or something)
     private String m;
 
+    private Map<String, Integer> mi;
+
+    private String extra;
+
     public GroupNotificationBinaryContent() {
     }
 
@@ -89,8 +95,23 @@ public class GroupNotificationBinaryContent {
         this.ms = ms;
     }
 
+    public GroupNotificationBinaryContent setMi(Map<String, Integer> mi) {
+        this.mi = mi;
+        return this;
+    }
+
+    public GroupNotificationBinaryContent setExtra(String extra) {
+        this.extra = extra;
+        return this;
+    }
+
     public WFCMessage.MessageContent getGroupNotifyContent(int groupContentType) {
-        return WFCMessage.MessageContent.newBuilder().setType(groupContentType).setData(ByteString.copyFromUtf8(new GsonBuilder().disableHtmlEscaping().create().toJson(this))).build();
+        WFCMessage.MessageContent.Builder builder = WFCMessage.MessageContent.newBuilder().setType(groupContentType).setData(ByteString.copyFromUtf8(new GsonBuilder().disableHtmlEscaping().create().toJson(this)));
+        if(!StringUtil.isNullOrEmpty(extra)) {
+            builder.setExtra(extra);
+        }
+        return builder.build();
+
     }
 
     public WFCMessage.MessageContent getAddGroupNotifyContent() {

common/src/main/java/cn/wildfirechat/pojos/InputAddGroupMember.java

@@ -17,6 +17,7 @@ import java.util.List;
 public class InputAddGroupMember extends InputGroupBase {
     private String group_id;
     private List<PojoGroupMember> members;
+    private String member_extra;
 
     public String getGroup_id() {
         return group_id;
@@ -34,6 +35,14 @@ public class InputAddGroupMember extends InputGroupBase {
         this.members = members;
     }
 
+    public String getMember_extra() {
+        return member_extra;
+    }
+
+    public void setMemberExtra(String extra) {
+        this.member_extra = extra;
+    }
+
     public boolean isValide() {
         return true;
     }
@@ -41,6 +50,9 @@ public class InputAddGroupMember extends InputGroupBase {
     public WFCMessage.AddGroupMemberRequest toProtoGroupRequest() {
         WFCMessage.AddGroupMemberRequest.Builder addGroupBuilder = WFCMessage.AddGroupMemberRequest.newBuilder();
         addGroupBuilder.setGroupId(group_id);
+        if(!StringUtil.isNullOrEmpty(member_extra)) {
+            addGroupBuilder.setExtra(member_extra);
+        }
         for (PojoGroupMember pojoGroupMember : getMembers()) {
             WFCMessage.GroupMember.Builder groupMemberBuilder = WFCMessage.GroupMember.newBuilder().setMemberId(pojoGroupMember.getMember_id());
             if (!StringUtil.isNullOrEmpty(pojoGroupMember.getAlias())) {

common/src/main/java/cn/wildfirechat/pojos/InputConferenceRequest.java

@@ -1,3 +1,11 @@
+/*
+ * 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 cn.wildfirechat.pojos;
 
 public class InputConferenceRequest {

common/src/main/java/cn/wildfirechat/pojos/InputCreateChannel.java

@@ -12,6 +12,9 @@ package cn.wildfirechat.pojos;
 import cn.wildfirechat.proto.WFCMessage;
 import io.netty.util.internal.StringUtil;
 
+import java.util.ArrayList;
+import java.util.List;
+
 public class InputCreateChannel {
     private String owner;
     private String name;
@@ -24,6 +27,7 @@ public class InputCreateChannel {
     private int state;
     private String extra;
     private long updateDt;
+    public List<PojoChannelMenu> menus;
 
     public WFCMessage.ChannelInfo toProtoChannelInfo() {
         WFCMessage.ChannelInfo.Builder builder = WFCMessage.ChannelInfo.newBuilder().setOwner(owner);
@@ -48,6 +52,12 @@ public class InputCreateChannel {
         else
             builder = builder.setUpdateDt(System.currentTimeMillis());
 
+        if (menus != null && !menus.isEmpty()) {
+            for (PojoChannelMenu menu : menus) {
+                builder.addMenu(menu.toPbInfo());
+            }
+        }
+
         return builder.build();
     }
 

common/src/main/java/cn/wildfirechat/pojos/InputCreateGroup.java

@@ -16,9 +16,10 @@ import java.util.List;
 
 public class InputCreateGroup extends InputGroupBase {
     private PojoGroup group;
+    private String member_extra;
 
     public boolean isValide() {
-        return true;
+        return !StringUtil.isNullOrEmpty(operator) && group != null;
     }
 
     public WFCMessage.CreateGroupRequest toProtoGroupRequest() {
@@ -68,6 +69,7 @@ public class InputCreateGroup extends InputGroupBase {
         if(group_info.isSuper_group()) {
             groupInfoBuilder.setSuperGroup(1);
         }
+        groupInfoBuilder.setDeleted(0);
 
         groupBuilder.setGroupInfo(groupInfoBuilder);
         if(group.getMembers() != null) {
@@ -86,6 +88,9 @@ public class InputCreateGroup extends InputGroupBase {
 
         WFCMessage.CreateGroupRequest.Builder createGroupReqBuilder = WFCMessage.CreateGroupRequest.newBuilder();
         createGroupReqBuilder.setGroup(groupBuilder);
+        if(!StringUtil.isNullOrEmpty(member_extra)) {
+            createGroupReqBuilder.setMemberExtra(member_extra);
+        }
         if (to_lines != null) {
             for (Integer line : to_lines
             ) {
@@ -106,4 +111,12 @@ public class InputCreateGroup extends InputGroupBase {
     public void setGroup(PojoGroup group) {
         this.group = group;
     }
+
+    public String getMember_extra() {
+        return member_extra;
+    }
+
+    public void setMember_extra(String member_extra) {
+        this.member_extra = member_extra;
+    }
 }

common/src/main/java/cn/wildfirechat/pojos/InputGetUserSK.java

@@ -0,0 +1,35 @@
+/*
+ * 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 cn.wildfirechat.pojos;
+
+public class InputGetUserSK {
+    private String uid;
+    private String cid;
+
+    public InputGetUserSK(String uid, String cid) {
+        this.uid = uid;
+        this.cid = cid;
+    }
+
+    public String getUid() {
+        return uid;
+    }
+
+    public void setUid(String uid) {
+        this.uid = uid;
+    }
+
+    public String getCid() {
+        return cid;
+    }
+
+    public void setCid(String cid) {
+        this.cid = cid;
+    }
+}

common/src/main/java/cn/wildfirechat/pojos/InputGroupBase.java

@@ -15,6 +15,7 @@ public class InputGroupBase {
     public String operator;
     public List<Integer> to_lines;
     public MessagePayload  notify_message;
+    private boolean isMeshMessage;
 
     public String getOperator() {
         return operator;
@@ -39,4 +40,12 @@ public class InputGroupBase {
     public void setNotify_message(MessagePayload notify_message) {
         this.notify_message = notify_message;
     }
+
+    public boolean isMeshMessage() {
+        return isMeshMessage;
+    }
+
+    public void setMeshMessage(boolean meshMessage) {
+        isMeshMessage = meshMessage;
+    }
 }

common/src/main/java/cn/wildfirechat/pojos/InputHandleFriendRequest.java

@@ -0,0 +1,50 @@
+/*
+ * 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 cn.wildfirechat.pojos;
+
+
+public class InputHandleFriendRequest {
+    private String userId;
+    private String friendUid;
+    private int status;
+    private boolean force;
+
+
+    public String getUserId() {
+        return userId;
+    }
+
+    public void setUserId(String userId) {
+        this.userId = userId;
+    }
+
+    public String getFriendUid() {
+        return friendUid;
+    }
+
+    public void setFriendUid(String friendUid) {
+        this.friendUid = friendUid;
+    }
+
+    public int getStatus() {
+        return status;
+    }
+
+    public void setStatus(int status) {
+        this.status = status;
+    }
+
+    public boolean isForce() {
+        return force;
+    }
+
+    public void setForce(boolean force) {
+        this.force = force;
+    }
+}

common/src/main/java/cn/wildfirechat/pojos/InputIntValue.java

@@ -0,0 +1,13 @@
+package cn.wildfirechat.pojos;
+
+public class InputIntValue {
+    public int value;
+
+    public int getValue() {
+        return value;
+    }
+
+    public void setValue(int value) {
+        this.value = value;
+    }
+}

common/src/main/java/cn/wildfirechat/pojos/InputOutputDomainInfo.java

@@ -0,0 +1,85 @@
+/*
+ * 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 cn.wildfirechat.pojos;
+
+
+public class InputOutputDomainInfo {
+    public String domainId;
+    public String name;
+    public String desc;
+    public String email;
+    public String tel;
+    public String address;
+    public String extra;
+    public long dt;
+
+    public String getDomainId() {
+        return domainId;
+    }
+
+    public void setDomainId(String domainId) {
+        this.domainId = domainId;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDesc() {
+        return desc;
+    }
+
+    public void setDesc(String desc) {
+        this.desc = desc;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    public String getTel() {
+        return tel;
+    }
+
+    public void setTel(String tel) {
+        this.tel = tel;
+    }
+
+    public String getAddress() {
+        return address;
+    }
+
+    public void setAddress(String address) {
+        this.address = address;
+    }
+
+    public String getExtra() {
+        return extra;
+    }
+
+    public void setExtra(String extra) {
+        this.extra = extra;
+    }
+
+    public long getDt() {
+        return dt;
+    }
+
+    public void setDt(long dt) {
+        this.dt = dt;
+    }
+}

common/src/main/java/cn/wildfirechat/pojos/InputOutputDomainInfoList.java

@@ -0,0 +1,24 @@
+/*
+ * 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 cn.wildfirechat.pojos;
+
+
+import java.util.List;
+
+public class InputOutputDomainInfoList {
+    public List<InputOutputDomainInfo> infos;
+
+    public List<InputOutputDomainInfo> getInfos() {
+        return infos;
+    }
+
+    public void setInfos(List<InputOutputDomainInfo> infos) {
+        this.infos = infos;
+    }
+}

common/src/main/java/cn/wildfirechat/pojos/InputStringList.java

@@ -0,0 +1,22 @@
+package cn.wildfirechat.pojos;
+
+import java.util.List;
+
+public class InputStringList {
+    private List<String> list;
+
+    public InputStringList() {
+    }
+
+    public InputStringList(List<String> list) {
+        this.list = list;
+    }
+
+    public List<String> getList() {
+        return list;
+    }
+
+    public void setList(List<String> list) {
+        this.list = list;
+    }
+}

common/src/main/java/cn/wildfirechat/pojos/InputStringValue.java

@@ -0,0 +1,13 @@
+package cn.wildfirechat.pojos;
+
+public class InputStringValue {
+    public String value;
+
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
+}

common/src/main/java/cn/wildfirechat/pojos/OutputCreateChannel.java

@@ -13,9 +13,11 @@ import cn.wildfirechat.proto.WFCMessage;
 
 public class OutputCreateChannel {
     private String targetId;
+    private String secret;
 
-    public OutputCreateChannel(String targetId) {
+    public OutputCreateChannel(String targetId, String secret) {
         this.targetId = targetId;
+        this.secret = secret;
     }
 
     public String getTargetId() {
@@ -25,4 +27,12 @@ public class OutputCreateChannel {
     public void setTargetId(String targetId) {
         this.targetId = targetId;
     }
+
+    public String getSecret() {
+        return secret;
+    }
+
+    public void setSecret(String secret) {
+        this.secret = secret;
+    }
 }

common/src/main/java/cn/wildfirechat/pojos/OutputGetChannelInfo.java

@@ -16,61 +16,7 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class OutputGetChannelInfo {
-    public static class OutputMenu {
-        public String menuId;
-        public String type;
-        public String name;
-        public String key;
-        public String url;
-        public String mediaId;
-        public String articleId;
-        public String appId;
-        public String appPage;
-        public String extra;
-        public List<OutputMenu> subMenus;
-
-        public static OutputMenu fromPbInfo(WFCMessage.ChannelMenu channelMenuMenu) {
-            OutputMenu out = new OutputMenu();
-            out.menuId = channelMenuMenu.getMenuId();
-            out.type = channelMenuMenu.getType();
-            out.name = channelMenuMenu.getName();
-            out.key = channelMenuMenu.getKey();
-            out.url = channelMenuMenu.getUrl();
-            out.mediaId = channelMenuMenu.getMediaId();
-            out.articleId = channelMenuMenu.getArticleId();
-            out.appId = channelMenuMenu.getAppId();
-            out.appPage = channelMenuMenu.getAppPage();
-            out.extra = channelMenuMenu.getExtra();
-            if (channelMenuMenu.getSubMenuCount() > 0) {
-                out.subMenus = new ArrayList<>();
-                for (WFCMessage.ChannelMenu menuMenu : channelMenuMenu.getSubMenuList()) {
-                    out.subMenus.add(fromPbInfo(menuMenu));
-                }
-            }
-            return out;
-        }
-
-        public WFCMessage.ChannelMenu.Builder toPbInfo() {
-            WFCMessage.ChannelMenu.Builder builder = WFCMessage.ChannelMenu.newBuilder();
-            builder.setType(type);
-            builder.setName(name);
-            if (!StringUtil.isNullOrEmpty(menuId)) builder.setMenuId(menuId);
-            if (!StringUtil.isNullOrEmpty(key)) builder.setKey(key);
-            if (!StringUtil.isNullOrEmpty(url)) builder.setUrl(url);
-            if (!StringUtil.isNullOrEmpty(mediaId)) builder.setMediaId(mediaId);
-            if (!StringUtil.isNullOrEmpty(articleId)) builder.setArticleId(articleId);
-            if (!StringUtil.isNullOrEmpty(appId)) builder.setAppId(appId);
-            if (!StringUtil.isNullOrEmpty(appPage)) builder.setAppPage(appPage);
-            if (!StringUtil.isNullOrEmpty(extra)) builder.setExtra(extra);
-            if (subMenus != null && !subMenus.isEmpty()) {
-                subMenus.forEach(menuMenu -> builder.addSubMenu(menuMenu.toPbInfo()));
-            }
-            return builder;
-        }
-    }
-
-    public static class OutputMenuList extends ArrayList<OutputMenu> {
-
+    public static class OutputMenuList extends ArrayList<PojoChannelMenu> {
     }
 
     private String channelId;
@@ -85,7 +31,7 @@ public class OutputGetChannelInfo {
     private String callback;
     private int automatic;
     private String secret;
-    public List<OutputMenu> menus;
+    public List<PojoChannelMenu> menus;
 
     public String getChannelId() {
         return channelId;
@@ -200,7 +146,7 @@ public class OutputGetChannelInfo {
         if (channelInfo.getMenuCount() > 0) {
             out.menus = new ArrayList<>();
             for (WFCMessage.ChannelMenu channelMenuMenu : channelInfo.getMenuList()) {
-                out.menus.add(OutputMenu.fromPbInfo(channelMenuMenu));
+                out.menus.add(PojoChannelMenu.fromPbInfo(channelMenuMenu));
             }
         }
         return out;

common/src/main/java/cn/wildfirechat/pojos/OutputGetIMTokenData.java

@@ -3,13 +3,15 @@ package cn.wildfirechat.pojos;
 public class OutputGetIMTokenData {
     private String userId;
     private String token;
+    private String serverLabel;
 
     public OutputGetIMTokenData() {
     }
 
-    public OutputGetIMTokenData(String userId, String imToken) {
+    public OutputGetIMTokenData(String userId, String imToken, String label) {
         this.userId = userId;
         this.token = imToken;
+        this.serverLabel = label;
     }
 
     public String getUserId() {
@@ -27,4 +29,12 @@ public class OutputGetIMTokenData {
     public void setToken(String token) {
         this.token = token;
     }
+
+    public String getServerLabel() {
+        return serverLabel;
+    }
+
+    public void setServerLabel(String serverLabel) {
+        this.serverLabel = serverLabel;
+    }
 }

common/src/main/java/cn/wildfirechat/pojos/OutputMessageData.java

@@ -22,6 +22,11 @@ public class OutputMessageData {
     private long timestamp;
     private OutputClient client;
 
+    private InputOutputUserInfo senderUserInfo;
+    private InputOutputUserInfo targetUserInfo;
+    private PojoGroupInfo targetGroupInfo;
+    private OutputGetChannelInfo targetChannelInfo;
+
     public String getSender() {
         return sender;
     }
@@ -78,6 +83,38 @@ public class OutputMessageData {
         this.client = client;
     }
 
+    public InputOutputUserInfo getSenderUserInfo() {
+        return senderUserInfo;
+    }
+
+    public void setSenderUserInfo(InputOutputUserInfo senderUserInfo) {
+        this.senderUserInfo = senderUserInfo;
+    }
+
+    public InputOutputUserInfo getTargetUserInfo() {
+        return targetUserInfo;
+    }
+
+    public void setTargetUserInfo(InputOutputUserInfo targetUserInfo) {
+        this.targetUserInfo = targetUserInfo;
+    }
+
+    public PojoGroupInfo getTargetGroupInfo() {
+        return targetGroupInfo;
+    }
+
+    public void setTargetGroupInfo(PojoGroupInfo targetGroupInfo) {
+        this.targetGroupInfo = targetGroupInfo;
+    }
+
+    public OutputGetChannelInfo getTargetChannelInfo() {
+        return targetChannelInfo;
+    }
+
+    public void setTargetChannelInfo(OutputGetChannelInfo targetChannelInfo) {
+        this.targetChannelInfo = targetChannelInfo;
+    }
+
     public static OutputMessageData fromProtoMessage(WFCMessage.Message protoMessage) {
         return fromProtoMessage(protoMessage, null);
     }

common/src/main/java/cn/wildfirechat/pojos/OutputReadData.java

@@ -1,5 +1,14 @@
+/*
+ * 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 cn.wildfirechat.pojos;
 
+
 public class OutputReadData {
     public String user;
     public Conversation conversation;

common/src/main/java/cn/wildfirechat/pojos/OutputUserInfoList.java

@@ -0,0 +1,18 @@
+/*
+ * 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 cn.wildfirechat.pojos;
+
+
+import cn.wildfirechat.proto.WFCMessage;
+
+import java.util.List;
+
+public class OutputUserInfoList {
+    public List<InputOutputUserInfo> userInfos;
+}

common/src/main/java/cn/wildfirechat/pojos/PojoChannelMenu.java

@@ -0,0 +1,60 @@
+package cn.wildfirechat.pojos;
+
+import cn.wildfirechat.proto.WFCMessage;
+import io.netty.util.internal.StringUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class PojoChannelMenu {
+    public String menuId;
+    public String type;
+    public String name;
+    public String key;
+    public String url;
+    public String mediaId;
+    public String articleId;
+    public String appId;
+    public String appPage;
+    public String extra;
+    public List<PojoChannelMenu> subMenus;
+
+    public static PojoChannelMenu fromPbInfo(WFCMessage.ChannelMenu channelMenuMenu) {
+        PojoChannelMenu out = new PojoChannelMenu();
+        out.menuId = channelMenuMenu.getMenuId();
+        out.type = channelMenuMenu.getType();
+        out.name = channelMenuMenu.getName();
+        out.key = channelMenuMenu.getKey();
+        out.url = channelMenuMenu.getUrl();
+        out.mediaId = channelMenuMenu.getMediaId();
+        out.articleId = channelMenuMenu.getArticleId();
+        out.appId = channelMenuMenu.getAppId();
+        out.appPage = channelMenuMenu.getAppPage();
+        out.extra = channelMenuMenu.getExtra();
+        if (channelMenuMenu.getSubMenuCount() > 0) {
+            out.subMenus = new ArrayList<>();
+            for (WFCMessage.ChannelMenu menuMenu : channelMenuMenu.getSubMenuList()) {
+                out.subMenus.add(fromPbInfo(menuMenu));
+            }
+        }
+        return out;
+    }
+
+    public WFCMessage.ChannelMenu.Builder toPbInfo() {
+        WFCMessage.ChannelMenu.Builder builder = WFCMessage.ChannelMenu.newBuilder();
+        builder.setType(type);
+        builder.setName(name);
+        if (!StringUtil.isNullOrEmpty(menuId)) builder.setMenuId(menuId);
+        if (!StringUtil.isNullOrEmpty(key)) builder.setKey(key);
+        if (!StringUtil.isNullOrEmpty(url)) builder.setUrl(url);
+        if (!StringUtil.isNullOrEmpty(mediaId)) builder.setMediaId(mediaId);
+        if (!StringUtil.isNullOrEmpty(articleId)) builder.setArticleId(articleId);
+        if (!StringUtil.isNullOrEmpty(appId)) builder.setAppId(appId);
+        if (!StringUtil.isNullOrEmpty(appPage)) builder.setAppPage(appPage);
+        if (!StringUtil.isNullOrEmpty(extra)) builder.setExtra(extra);
+        if (subMenus != null && !subMenus.isEmpty()) {
+            subMenus.forEach(menuMenu -> builder.addSubMenu(menuMenu.toPbInfo()));
+        }
+        return builder;
+    }
+}

common/src/main/java/cn/wildfirechat/pojos/PojoGroupInfo.java

@@ -14,6 +14,7 @@ public class PojoGroupInfo {
     String portrait;
     String owner;
     int type;
+    int member_count;
     String extra;
     int mute;
     int join_type;
@@ -22,6 +23,9 @@ public class PojoGroupInfo {
     int max_member_count;
     int history_message;
     boolean super_group;
+    boolean deleted;
+    long update_dt;
+    long member_update_dt;
 
     public String getTarget_id() {
         return target_id;
@@ -126,4 +130,36 @@ public class PojoGroupInfo {
     public void setSuper_group(boolean super_group) {
         this.super_group = super_group;
     }
+
+    public boolean isDeleted() {
+        return deleted;
+    }
+
+    public void setDeleted(boolean deleted) {
+        this.deleted = deleted;
+    }
+
+    public long getUpdate_dt() {
+        return update_dt;
+    }
+
+    public void setUpdate_dt(long update_dt) {
+        this.update_dt = update_dt;
+    }
+
+    public int getMember_count() {
+        return member_count;
+    }
+
+    public void setMember_count(int member_count) {
+        this.member_count = member_count;
+    }
+
+    public long getMember_update_dt() {
+        return member_update_dt;
+    }
+
+    public void setMember_update_dt(long member_update_dt) {
+        this.member_update_dt = member_update_dt;
+    }
 }

common/src/main/java/cn/wildfirechat/pojos/PojoGroupInfoList.java

@@ -0,0 +1,23 @@
+/*
+ * 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 cn.wildfirechat.pojos;
+
+import java.util.List;
+
+public class PojoGroupInfoList {
+    public List<PojoGroupInfo> groupInfoList;
+
+    public List<PojoGroupInfo> getGroupInfoList() {
+        return groupInfoList;
+    }
+
+    public void setGroupInfoList(List<PojoGroupInfo> groupInfoList) {
+        this.groupInfoList = groupInfoList;
+    }
+}

common/src/main/java/cn/wildfirechat/pojos/PojoGroupMember.java

@@ -13,6 +13,7 @@ public class PojoGroupMember {
     String alias;
     int type;
     String extra;
+    long updateDt;
     long createDt;
 
     public String getMember_id() {
@@ -47,6 +48,14 @@ public class PojoGroupMember {
         this.extra = extra;
     }
 
+    public long getUpdateDt() {
+        return updateDt;
+    }
+
+    public void setUpdateDt(long updateDt) {
+        this.updateDt = updateDt;
+    }
+
     public long getCreateDt() {
         return createDt;
     }

common/src/main/java/cn/wildfirechat/pojos/RecallMessageData.java

@@ -14,6 +14,7 @@ import io.netty.util.internal.StringUtil;
 public class RecallMessageData {
     private String operator;
     private long messageUid;
+    private boolean isUserRecall;
 
     public String getOperator() {
         return operator;
@@ -30,4 +31,12 @@ public class RecallMessageData {
     public void setMessageUid(long messageUid) {
         this.messageUid = messageUid;
     }
+
+    public boolean isUserRecall() {
+        return isUserRecall;
+    }
+
+    public void setUserRecall(boolean userRecall) {
+        isUserRecall = userRecall;
+    }
 }

common/src/main/java/cn/wildfirechat/pojos/ReplyMessageData.java

@@ -0,0 +1,52 @@
+/*
+ * 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 cn.wildfirechat.pojos;
+
+import cn.wildfirechat.proto.WFCMessage;
+import io.netty.util.internal.StringUtil;
+
+import java.util.List;
+
+public class ReplyMessageData {
+    private long messageUid;
+    private MessagePayload payload;
+    private boolean only2Sender;
+
+    public long getMessageUid() {
+        return messageUid;
+    }
+
+    public void setMessageUid(long messageUid) {
+        this.messageUid = messageUid;
+    }
+
+    public MessagePayload getPayload() {
+        return payload;
+    }
+
+    public void setPayload(MessagePayload payload) {
+        this.payload = payload;
+    }
+
+    public boolean isOnly2Sender() {
+        return only2Sender;
+    }
+
+    public void setOnly2Sender(boolean only2Sender) {
+        this.only2Sender = only2Sender;
+    }
+
+    public static boolean isValide(ReplyMessageData sendMessageData) {
+        if(sendMessageData.messageUid <=0  ||
+            sendMessageData.getPayload() == null) {
+            return false;
+        }
+        return true;
+    }
+}

common/src/main/java/cn/wildfirechat/pojos/RepublishChannelMessageData.java

@@ -0,0 +1,32 @@
+/*
+ * 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 cn.wildfirechat.pojos;
+
+import java.util.List;
+
+public class RepublishChannelMessageData {
+    private List<String> targets;
+    private long messageId;
+
+    public List<String> getTargets() {
+        return targets;
+    }
+
+    public void setTargets(List<String> targets) {
+        this.targets = targets;
+    }
+
+    public long getMessageId() {
+        return messageId;
+    }
+
+    public void setMessageId(long messageId) {
+        this.messageId = messageId;
+    }
+}

common/src/main/java/cn/wildfirechat/pojos/SendMessageData.java

@@ -19,6 +19,8 @@ public class SendMessageData {
     private Conversation conv;
     private MessagePayload payload;
     private List<String> toUsers;
+    private boolean isMeshMessage;
+    private boolean isUserMessage;
 
     public String getSender() {
         return sender;
@@ -52,6 +54,22 @@ public class SendMessageData {
         this.toUsers = toUsers;
     }
 
+    public boolean isMeshMessage() {
+        return isMeshMessage;
+    }
+
+    public void setMeshMessage(boolean meshMessage) {
+        isMeshMessage = meshMessage;
+    }
+
+    public boolean isUserMessage() {
+        return isUserMessage;
+    }
+
+    public void setUserMessage(boolean userMessage) {
+        isUserMessage = userMessage;
+    }
+
     public static boolean isValide(SendMessageData sendMessageData) {
         if(sendMessageData == null ||
             sendMessageData.getConv() == null ||

common/src/main/java/cn/wildfirechat/pojos/UpdateMessageContentData.java

@@ -14,6 +14,7 @@ public class UpdateMessageContentData {
     private MessagePayload payload;
     private int distribute;
     private int updateTimestamp;
+    private int meshLocal;
 
     public String getOperator() {
         return operator;
@@ -54,4 +55,12 @@ public class UpdateMessageContentData {
     public void setUpdateTimestamp(int updateTimestamp) {
         this.updateTimestamp = updateTimestamp;
     }
+
+    public int getMeshLocal() {
+        return meshLocal;
+    }
+
+    public void setMeshLocal(int meshLocal) {
+        this.meshLocal = meshLocal;
+    }
 }

common/src/main/java/cn/wildfirechat/pojos/mesh/MeshRestResult.java

@@ -0,0 +1,139 @@
+package cn.wildfirechat.pojos.mesh;
+
+import com.google.gson.Gson;
+
+public class MeshRestResult<T> {
+    private static Gson gson = new Gson();
+    public enum MeshRestCode {
+        SUCCESS(0, "success"),
+        ERROR_INVALID_MOBILE(1, "无效的电话号码"),
+        ERROR_SEND_SMS_OVER_FREQUENCY(3, "请求验证码太频繁"),
+        ERROR_SERVER_ERROR(4, "服务器异常"),
+        ERROR_CODE_EXPIRED(5, "验证码已过期"),
+        ERROR_CODE_INCORRECT(6, "验证码或密码错误"),
+        ERROR_SERVER_CONFIG_ERROR(7, "服务器配置错误"),
+        ERROR_SESSION_EXPIRED(8, "会话不存在或已过期"),
+        ERROR_SESSION_NOT_VERIFIED(9, "会话没有验证"),
+        ERROR_SESSION_NOT_SCANED(10, "会话没有被扫码"),
+        ERROR_SERVER_NOT_IMPLEMENT(11, "功能没有实现"),
+        ERROR_GROUP_ANNOUNCEMENT_NOT_EXIST(12, "群公告不存在"),
+        ERROR_NOT_LOGIN(13, "没有登录"),
+        ERROR_NO_RIGHT(14, "没有权限"),
+        ERROR_INVALID_PARAMETER(15, "无效参数"),
+        ERROR_NOT_EXIST(16, "对象不存在"),
+        ERROR_USER_NAME_ALREADY_EXIST(17, "用户名已经存在"),
+        ERROR_SESSION_CANCELED(18, "会话已经取消"),
+        ERROR_PASSWORD_INCORRECT(19, "密码错误"),
+        ERROR_FAILURE_TOO_MUCH_TIMES(20, "密码错误次数太多，请等5分钟再试试"),
+        ERROR_USER_FORBIDDEN(21, "用户被封禁");
+        public int code;
+        public String msg;
+
+        MeshRestCode(int code, String msg) {
+            this.code = code;
+            this.msg = msg;
+        }
+
+    }
+    private int remote_im_code;
+    private int remote_mesh_code;
+    private int local_mesh_code;
+    private String error_message;
+    private T result;
+
+    @Override
+    public String toString() {
+        return gson.toJson(this);
+    }
+
+    public static MeshRestResult ok() {
+        return new MeshRestResult();
+    }
+
+    public static MeshRestResult ok(Object object) {
+        return new MeshRestResult(object);
+    }
+
+    public static MeshRestResult remoteIMError(int code, String message) {
+        MeshRestResult r = new MeshRestResult();
+        r.remote_im_code = code;
+        r.error_message = message;
+        return r;
+    }
+
+    public static MeshRestResult remoteMeshError(int code, String message) {
+        MeshRestResult r = new MeshRestResult();
+        r.remote_mesh_code = code;
+        r.error_message = message;
+        return r;
+    }
+
+    public MeshRestResult addRemoteMeshError(int code, String message) {
+        MeshRestResult r = new MeshRestResult();
+        remote_mesh_code = code;
+        error_message = message;
+        return this;
+    }
+
+    public static MeshRestResult localMeshError(int code, String message) {
+        MeshRestResult r = new MeshRestResult();
+        r.local_mesh_code = code;
+        r.error_message = message;
+        return r;
+    }
+
+    public MeshRestResult addLocalMeshError(int code, String message) {
+        local_mesh_code = code;
+        error_message = message;
+        return this;
+    }
+
+
+    public MeshRestResult() {
+
+    }
+
+    public MeshRestResult(T object) {
+        result = object;
+    }
+
+    public T getResult() {
+        return result;
+    }
+
+    public void setResult(T result) {
+        this.result = result;
+    }
+
+    public int getRemote_im_code() {
+        return remote_im_code;
+    }
+
+    public void setRemote_im_code(int remote_im_code) {
+        this.remote_im_code = remote_im_code;
+    }
+
+    public int getRemote_mesh_code() {
+        return remote_mesh_code;
+    }
+
+    public void setRemote_mesh_code(int remote_mesh_code) {
+        this.remote_mesh_code = remote_mesh_code;
+    }
+
+    public int getLocal_mesh_code() {
+        return local_mesh_code;
+    }
+
+    public void setLocal_mesh_code(int local_mesh_code) {
+        this.local_mesh_code = local_mesh_code;
+    }
+
+    public String getError_message() {
+        return error_message;
+    }
+
+    public void setError_message(String error_message) {
+        this.error_message = error_message;
+    }
+}

common/src/main/java/cn/wildfirechat/pojos/mesh/PojoAddFriendReq.java

@@ -0,0 +1,8 @@
+package cn.wildfirechat.pojos.mesh;
+
+public class PojoAddFriendReq {
+    public String fromUserId;
+    public String reason;
+    public String targetUserId;
+    public String domainId;
+}

common/src/main/java/cn/wildfirechat/pojos/mesh/PojoAddGroupMember.java

@@ -0,0 +1,44 @@
+package cn.wildfirechat.pojos.mesh;
+
+import cn.wildfirechat.pojos.PojoGroupMember;
+
+import java.util.List;
+
+public class PojoAddGroupMember {
+    public String domainId;
+    public String operator;
+    public String group_id;
+    public List<PojoGroupMember> members;
+
+    public String getOperator() {
+        return operator;
+    }
+
+    public void setOperator(String operator) {
+        this.operator = operator;
+    }
+
+    public String getGroup_id() {
+        return group_id;
+    }
+
+    public void setGroup_id(String group_id) {
+        this.group_id = group_id;
+    }
+
+    public List<PojoGroupMember> getMembers() {
+        return members;
+    }
+
+    public void setMembers(List<PojoGroupMember> members) {
+        this.members = members;
+    }
+
+    public String getDomainId() {
+        return domainId;
+    }
+
+    public void setDomainId(String domainId) {
+        this.domainId = domainId;
+    }
+}

common/src/main/java/cn/wildfirechat/pojos/mesh/PojoDeleteFriend.java

@@ -0,0 +1,31 @@
+package cn.wildfirechat.pojos.mesh;
+
+public class PojoDeleteFriend {
+    public String domainId;
+    public String operator;
+    public String friendUid;
+
+    public String getOperator() {
+        return operator;
+    }
+
+    public void setOperator(String operator) {
+        this.operator = operator;
+    }
+
+    public String getFriendUid() {
+        return friendUid;
+    }
+
+    public void setFriendUid(String friendUid) {
+        this.friendUid = friendUid;
+    }
+
+    public String getDomainId() {
+        return domainId;
+    }
+
+    public void setDomainId(String domainId) {
+        this.domainId = domainId;
+    }
+}

common/src/main/java/cn/wildfirechat/pojos/mesh/PojoDismissGroup.java

@@ -0,0 +1,31 @@
+package cn.wildfirechat.pojos.mesh;
+
+public class PojoDismissGroup {
+    public String domainId;
+    public String operator;
+    public String group_id;
+
+    public String getOperator() {
+        return operator;
+    }
+
+    public void setOperator(String operator) {
+        this.operator = operator;
+    }
+
+    public String getGroup_id() {
+        return group_id;
+    }
+
+    public void setGroup_id(String group_id) {
+        this.group_id = group_id;
+    }
+
+    public String getDomainId() {
+        return domainId;
+    }
+
+    public void setDomainId(String domainId) {
+        this.domainId = domainId;
+    }
+}

common/src/main/java/cn/wildfirechat/pojos/mesh/PojoDomainPingRequest.java

@@ -0,0 +1,14 @@
+/*
+ * 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 cn.wildfirechat.pojos.mesh;
+
+
+public class PojoDomainPingRequest {
+    public String domainId;
+}

common/src/main/java/cn/wildfirechat/pojos/mesh/PojoDomainPingResponse.java

@@ -0,0 +1,16 @@
+/*
+ * 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 cn.wildfirechat.pojos.mesh;
+
+
+public class PojoDomainPingResponse {
+    public boolean success;
+    public String errorMessage;
+    public String myDomainName;
+}

common/src/main/java/cn/wildfirechat/pojos/mesh/PojoGroupUpdated.java

@@ -0,0 +1,36 @@
+package cn.wildfirechat.pojos.mesh;
+
+import cn.wildfirechat.pojos.PojoGroupInfo;
+import cn.wildfirechat.pojos.PojoGroupMember;
+
+import java.util.List;
+
+public class PojoGroupUpdated {
+    public List<String> domainIds;
+    public PojoGroupInfo groupInfo;
+    public List<PojoGroupMember> members;
+
+    public List<String> getDomainIds() {
+        return domainIds;
+    }
+
+    public void setDomainIds(List<String> domainIds) {
+        this.domainIds = domainIds;
+    }
+
+    public PojoGroupInfo getGroupInfo() {
+        return groupInfo;
+    }
+
+    public void setGroupInfo(PojoGroupInfo groupInfo) {
+        this.groupInfo = groupInfo;
+    }
+
+    public List<PojoGroupMember> getMembers() {
+        return members;
+    }
+
+    public void setMembers(List<PojoGroupMember> members) {
+        this.members = members;
+    }
+}