-
Notifications
You must be signed in to change notification settings - Fork 0
/
KookCli.java
356 lines (296 loc) · 12.6 KB
/
KookCli.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
package net.deechael.kookcli;
import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.mojang.brigadier.CommandDispatcher;
import net.deechael.kookcli.command.Console;
import net.deechael.kookcli.command.ConsoleSender;
import net.deechael.kookcli.command.defaults.*;
import net.deechael.kookcli.network.Routes;
import net.deechael.kookcli.plugin.PluginManager;
import net.deechael.kookcli.util.ZlibUtil;
import okhttp3.*;
import okio.ByteString;
import org.jetbrains.annotations.NotNull;
import org.jline.reader.LineReader;
import org.jline.terminal.Terminal;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import uk.org.lidalia.sysoutslf4j.context.SysOutOverSLF4J;
import java.io.IOException;
import java.util.*;
import java.util.concurrent.TimeUnit;
public final class KookCli {
private final static CommandDispatcher<ConsoleSender> COMMAND_DISPATCHER = new CommandDispatcher<>();
private final static ConsoleSender SENDER = new ConsoleSender();
private final static Gson GSON = new Gson();
private final static PluginManager PLUGIN_MANAGER = new PluginManager();
private final static OkHttpClient HTTP_CLIENT = new OkHttpClient.Builder()
.pingInterval(28, TimeUnit.SECONDS)
.build();
private final static Receiver RECEIVER = new Receiver();
// private final static Logger LOGGER = LoggerUtil.getLogger(KookCli.class, Level.INFO);
private final static Logger LOGGER = LoggerFactory.getLogger("KookCli");
private static Terminal terminal;
private static LineReader lineReader;
private static boolean logged_in;
private static String auth;
private static WebSocket webSocket;
private static String currentGuild;
private static String currentChannel;
public static ConsoleSender getConsoleSender() {
return SENDER;
}
public static CommandDispatcher<ConsoleSender> getCommandDispatcher() {
return COMMAND_DISPATCHER;
}
private static void registerCommands() {
CommandDispatcher<ConsoleSender> commandDispatcher = KookCli.getCommandDispatcher();
PluginsCommand.register(commandDispatcher);
LoginCommand.register(commandDispatcher);
LogoutCommand.register(commandDispatcher);
InfoCommand.register(commandDispatcher);
GuildCommand.register(commandDispatcher);
ChannelCommand.register(commandDispatcher);
SendCommand.register(commandDispatcher);
ExitCommand.register(commandDispatcher);
}
public static void main() {
SysOutOverSLF4J.registerLoggingSystem("org.apache.logging");
SysOutOverSLF4J.sendSystemOutAndErrToSLF4J();
registerCommands();
Console console = new Console();
PLUGIN_MANAGER.load();
console.start();
}
public static PluginManager getPluginManager() {
return PLUGIN_MANAGER;
}
public static boolean isLogged() {
return logged_in;
}
public static void login(String token) {
if (isLogged())
throw new RuntimeException("Has logged in!");
auth = "Bot " + token;
logged_in = true;
startWebsocket();
}
public static void login(String phone, String password) {
JsonObject params = new JsonObject();
params.addProperty("mobile", phone);
params.addProperty("mobile_prefix", "86");
params.addProperty("password", password);
params.addProperty("remember", false);
Request req = new Request.Builder()
.post(RequestBody
.create(GSON.toJson(params),
MediaType.get("application/json")))
.header("Content-type", "application/json")
.url(Routes.AUTH_LOGIN).build();
Call call = HTTP_CLIENT.newCall(req);
call.enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
Thread.currentThread().setName("websocket");
LOGGER.error("Failed to login", e);
}
@Override
public void onResponse(Call call, Response response) throws IOException {
Thread.currentThread().setName("websocket");
LOGGER.debug("Logged successfully");
JsonObject body = JsonParser.parseString(Objects.requireNonNull(response.body()).string()).getAsJsonObject();
if (!body.has("token")) {
LOGGER.error("Failed to fetch token");
return;
}
auth = body.get("token").getAsString();
JsonObject userInfo = body.getAsJsonObject("user");
LOGGER.info("Login as " + userInfo.get("username").getAsString() + "#" + userInfo.get("identify_num").getAsString());
if (auth == null)
return;
logged_in = true;
startWebsocket();
}
});
}
public static void logout() {
if (webSocket != null) {
webSocket.close(1000, "normal");
}
webSocket = null;
auth = null;
logged_in = false;
currentGuild = null;
currentChannel = null;
}
public static boolean isBot() {
return auth != null && auth.startsWith("Bot");
}
public static JsonObject getRequest(String url, Map<String, String> params) {
StringBuilder stringBuilder = new StringBuilder(url);
if (params.size() > 0) {
stringBuilder.append("?");
for (Map.Entry<String, String> entry : params.entrySet()) {
stringBuilder.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
}
url = new StringBuilder(stringBuilder.reverse().substring(1)).reverse().toString();
}
Request req = new Request.Builder()
.get()
.header("Content-type", "application/json")
.header("Authorization", auth)
.header("Cookie", cookieHeader(Collections.singletonList(new Cookie.Builder().name("auth").domain("kookapp.cn").value(auth).build())))
.url(url).build();
return call(url, req);
}
public static List<JsonObject> getPageableRequest(String url, Map<String, String> params) {
params.put("page", "1");
params.put("page_size", "50");
JsonObject firstData = getRequest(url, params);
int total = firstData.getAsJsonObject("data").getAsJsonObject("meta").get("total").getAsInt();
List<JsonObject> objects = new ArrayList<>();
for (JsonElement element : firstData.getAsJsonObject("data").getAsJsonArray("items")) {
objects.add(element.getAsJsonObject());
}
if (total > 50) {
int pages = total % 50 == 0 ? total / 50 : total / 50 + 1;
for (int page = 2; page <= pages; page++) {
params.put("page", "" + page);
JsonObject data = getRequest(url, params);
for (JsonElement element : data.getAsJsonObject("data").getAsJsonArray("items")) {
objects.add(element.getAsJsonObject());
}
}
}
return objects;
}
public static JsonObject postRequest(String url, JsonObject params) {
Request req = new Request.Builder()
.post(RequestBody
.create(GSON.toJson(params),
MediaType.get("application/json")))
.header("Authorization", auth)
.header("Cookie", cookieHeader(Collections.singletonList(new Cookie.Builder().name("auth").domain("kookapp.cn").value(auth).build())))
.header("Content-type", "application/json")
.url(url).build();
return call(url, req);
}
private static JsonObject call(String url, Request req) {
Call call = HTTP_CLIENT.newCall(req);
try {
Response response = call.execute();
JsonObject body = JsonParser.parseString(Objects.requireNonNull(response.body()).string()).getAsJsonObject();
if (body.get("code").getAsInt() != 0)
LOGGER.error("Failed to request, response: " + body);
return body;
} catch (IOException e) {
LOGGER.error("Failed to request: " + url, e);
throw new RuntimeException(e);
}
}
public static void setCurrentChannel(String currentChannel) {
KookCli.currentChannel = currentChannel;
}
public static void setCurrentGuild(String currentGuild) {
KookCli.currentGuild = currentGuild;
currentChannel = null;
}
public static String getCurrentChannel() {
return currentChannel;
}
public static String getCurrentGuild() {
return currentGuild;
}
public static void exit() {
logout();
PLUGIN_MANAGER.unload();
System.exit(0);
}
public static LineReader getLineReader() {
return lineReader;
}
public static Terminal getTerminal() {
return terminal;
}
public static void setLineReader(LineReader lineReader) {
KookCli.lineReader = lineReader;
}
public static void setTerminal(Terminal terminal) {
KookCli.terminal = terminal;
}
private static void startWebsocket() {
Request req = new Request.Builder()
.post(RequestBody.create(new byte[0], MediaType.get("application/json")))
.header("Authorization", auth)
.header("Cookie", cookieHeader(Collections.singletonList(new Cookie.Builder().name("auth").domain("kookapp.cn").value(auth).build())))
.header("Content-type", "application/json")
.url(Routes.GATEWAY).build();
Call call = HTTP_CLIENT.newCall(req);
call.enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
Thread.currentThread().setName("websocket");
LOGGER.error("Failed to fetch the websocket url", e);
logged_in = false;
auth = null;
webSocket = null;
}
@Override
public void onResponse(Call call, Response response) throws IOException {
Thread.currentThread().setName("websocket");
LOGGER.debug("Fetched websocket url successfully");
JsonObject body = JsonParser.parseString(Objects.requireNonNull(response.body()).string()).getAsJsonObject();
String url = body.getAsJsonObject("data").get("url").getAsString();
LOGGER.debug("Websocket url: " + url);
webSocket = HTTP_CLIENT.newWebSocket(new Request.Builder().get().url(url).build(), RECEIVER);
LOGGER.info("Login successfully!");
}
});
}
public static Logger getLogger() {
return LOGGER;
}
private static String cookieHeader(List<Cookie> cookies) {
StringBuilder cookieHeader = new StringBuilder();
int i = 0;
for (int size = cookies.size(); i < size; ++i) {
if (i > 0) {
cookieHeader.append("; ");
}
Cookie cookie = cookies.get(i);
cookieHeader.append(cookie.name()).append('=').append(cookie.value());
}
return cookieHeader.toString();
}
private KookCli() {
}
private static class Receiver extends WebSocketListener {
@Override
public void onOpen(@NotNull WebSocket webSocket, @NotNull Response response) {
Thread.currentThread().setName("websocket");
}
@Override
public void onMessage(@NotNull WebSocket webSocket, @NotNull String text) {
JsonObject object = JsonParser.parseString(text).getAsJsonObject();
LOGGER.debug("Received: " + object);
if (!object.has("s"))
return;
if (object.get("s").getAsInt() != 0) {
}
}
@Override
public void onMessage(@NotNull WebSocket webSocket, @NotNull ByteString bytes) {
this.onMessage(webSocket, new String(ZlibUtil.decompress(bytes.toByteArray())));
}
@Override
public void onClosed(@NotNull WebSocket webSocket, int code, @NotNull String reason) {
LOGGER.debug("WebSocket connection has been closed");
}
@Override
public void onFailure(@NotNull WebSocket webSocket, @NotNull Throwable throwable, Response response) {
LOGGER.error("Failed to connect to websocket", throwable);
}
}
}