· 6 years ago · Dec 26, 2019, 08:06 AM
1class JagTagCommand : Command(), SQLUtils {
2 private val tags: HashSet<Tag> = HashSet()
3 private val tagCache: HashSet<Tag> = HashSet()
4
5 override fun execute(event: CommandEvent?) {
6 val args = event?.args?.split("\\s+".toRegex())?.toTypedArray()
7 val authorID = event?.author?.id
8 val guildID = event?.guild?.id
9 val jagtag = buildParser(event!!)
10 var matchFound = false
11 event.channel.sendTyping().queue()
12 try {
13 when (args?.get(0)) {
14 "global", "g" -> {
15 when (args[1]) {
16 "create", "new", "add" -> {
17 if (args[2].matches(
18 "(global|g|create|new|add|delete|remove|edit|modify|raw|cblkraw)".toRegex())
19 ) throw CommandException("Be unique, these are reserved command parameters.")
20 select(ALL)
21 val tagValue = Arrays.stream(args).skip(3).collect(Collectors.joining(" "))
22 if (event.message.attachments.isNotEmpty()) {
23 insert(LVALUE, "${event.message.attachments[0].proxyUrl} $tagValue", authorID)
24 } else insert(GVALUE, args[2], tagValue, authorID)
25 select(ALL)
26 tags.clear()
27 tags.addAll(tagCache)
28 }
29 "delete", "remove" -> {
30 select(ALL)
31 if (exists(GVALUE, args[2])) delete(LVALUE, args[2], authorID)
32 else throw CommandException("Deleting something that does not exist.")
33 select(ALL)
34 tags.clear()
35 tags.addAll(tagCache)
36 }
37 "edit", "modify" -> {
38 select(ALL)
39 val tagValue = Arrays.stream(args).skip(3).collect(Collectors.joining(" "))
40 update(GVALUE, args[2], tagValue, authorID)
41 select(ALL)
42 tags.clear()
43 tags.addAll(tagCache)
44 }
45 }
46 }
47 "create", "new", "add" -> {
48 if (event.isFromType(ChannelType.PRIVATE)) throw CommandException("Use the global parameter.")
49 if (args[1].matches(
50 "(global|g|create|new|add|delete|remove|edit|modify|raw|cblkraw)".toRegex())
51 ) throw CommandException("Be unique, these are reserved command parameters.")
52 select(ALL)
53 val tagValue = Arrays.stream(args).skip(2).collect(Collectors.joining(" "))
54 if (event.message.attachments.isNotEmpty()) {
55 insert(LVALUE, "${event.message.attachments[0].proxyUrl} $tagValue", authorID, guildID)
56 } else insert(LVALUE, args[1], tagValue, authorID, guildID)
57 select(ALL)
58 tags.clear()
59 tags.addAll(tagCache)
60 }
61 "delete", "remove" -> {
62 if (event.isFromType(ChannelType.PRIVATE)) throw CommandException("Use the global parameter.")
63 select(ALL)
64 if (exists(LVALUE, args[1], guildID)) delete(LVALUE, args[1], authorID, guildID)
65 else throw CommandException("Deleting something that does not exist.")
66 select(ALL)
67 tags.clear()
68 tags.addAll(tagCache)
69 }
70 "edit", "modify" -> {
71 if (event.isFromType(ChannelType.PRIVATE)) throw CommandException("Use the global parameter.")
72 select(ALL)
73 val tagValue = Arrays.stream(args).skip(2).collect(Collectors.joining(" "))
74 update(LVALUE, args[1], tagValue, authorID, guildID)
75 select(ALL)
76 tags.clear()
77 tags.addAll(tagCache)
78 }
79 "raw" -> tags.stream().filter {t -> t.tagKey == args[0] }.forEachOrdered { t ->
80 if (t.guildID == guildID || t.guildID == "GLOBAL") event.reply(t.tagValue)
81 else throw CommandException("Tag not found.")
82 }
83 "cblkraw" -> tags.stream().filter { t -> t.tagKey == args[0] }.forEachOrdered { t ->
84 if (t.guildID == guildID || t.guildID == "GLOBAL") event.reply("```" + t.tagValue + "```")
85 else throw CommandException("Tag not found.")
86 }
87 "eval" -> {
88 event.reply("Type `!!stop` to exit.")
89 val id = event.channel.id
90 event.jda.addEventListener(
91 object : ListenerAdapter() {
92 override fun onGuildMessageReceived(event: GuildMessageReceivedEvent) {
93 if (event.author.isBot || event.author.isFake || event.channel.id != id) return
94 event.channel.sendTyping().queue()
95 val message = event.message.contentRaw.split("\\s+").toTypedArray()
96 val arguments = message.joinToString(" ")
97 val parser = buildParser(event)
98 if (message[0].equals("!!stop", ignoreCase = true))
99 event.jda.removeEventListener(this)
100 else event.channel.sendMessage(parser.parse(arguments)).queue()
101 }
102 }
103 )
104 }
105 else -> tags.stream().filter { t -> t.tagKey == args?.get(0) }
106 .takeWhile { !matchFound }
107 .forEachOrdered { t ->
108 when (t.guildID) {
109 guildID -> {
110 matchFound = true
111 event.reply(jagtag.parse(t.tagValue))
112 }
113 "GLOBAL" -> {
114 matchFound = true
115 event.reply("No local tags of the name ${t.tagKey}.")
116 event.reply(jagtag.parse(t.tagValue))
117 }
118 else -> throw CommandException("Tag not found.")
119 }
120 }
121 }
122 } catch (s: SQLException) {
123 event.reply(s.message)
124 if (s.errorCode == 19) throw CommandException("Tag exists or missing parameters.")
125 else throw CommandException(s.message + s.message)
126 }
127
128 }
129
130 private fun buildParser(event: Any): Parser {
131 val cvt = AtomicReference<CommandEvent>()
132 val gvt = AtomicReference<GuildMessageReceivedEvent>()
133
134 if (event is CommandEvent) cvt.set(event)
135 else gvt.set(event as GuildMessageReceivedEvent)
136
137 if (cvt.get() != null) {
138 return JagTag.newDefaultBuilder().addMethods(listOf(
139 Method("author") { _ -> cvt.get().author.name },
140 Method("mAuthor") { _ -> cvt.get().author.asMention },
141 Method("guild") { _ -> cvt.get().guild.name },
142 Method("guildID") { _ -> cvt.get().guild.id},
143 Method("memberCount") { _ -> cvt.get().guild.memberCount.toString() },
144 Method("boostCount") { _ -> cvt.get().guild.boostCount.toString() },
145 Method("owner") { _ -> cvt.get().guild.owner?.effectiveName},
146 Method("ownerID") { _ -> cvt.get().guild.ownerId },
147 Method("roles") { _ -> cvt.get().guild.roles.stream()
148 .map(Role::getName).collect(Collectors.joining(", "))},
149 Method("randMember") { _ -> cvt.get().guild.members[SecureRandom().nextInt(cvt.get().guild.members.size)]
150 .effectiveName },
151 Method("randChannel") { _ -> cvt.get().guild
152 .channels[SecureRandom().nextInt(cvt.get().guild.channels.size)].name },
153 Method("strlen") { _ -> (cvt.get().args.split("\\s+".toRegex()).size - 1).toString() },
154 Method("date") { _ -> SimpleDateFormat("MM-dd-yyyy").format(Date()) }
155 )).build()
156 } else {
157 return JagTag.newDefaultBuilder().addMethods(listOf(
158 Method("author") { _ -> gvt.get().author.name },
159 Method("mAuthor") { _ -> gvt.get().author.asMention },
160 Method("guild") { _ -> gvt.get().guild.name },
161 Method("guildID") { _ -> gvt.get().guild.id},
162 Method("memberCount") { _ -> gvt.get().guild.memberCount.toString() },
163 Method("boostCount") { _ -> gvt.get().guild.boostCount.toString() },
164 Method("owner") { _ -> gvt.get().guild.owner?.effectiveName},
165 Method("ownerID") { _ -> gvt.get().guild.ownerId },
166 Method("roles") { _ -> gvt.get().guild.roles.stream()
167 .map(Role::getName).collect(Collectors.joining(", "))},
168 Method("randMember") { _ -> gvt.get().guild.members[SecureRandom().nextInt(cvt.get().guild.members.size)]
169 .effectiveName },
170 Method("randChannel") { _ -> gvt.get().guild
171 .channels[SecureRandom().nextInt(cvt.get().guild.channels.size)].name },
172 Method("strlen") { _ -> (gvt.get().message.contentRaw.split("\\s+".toRegex()).size - 1).toString() },
173 Method("date") { _ -> SimpleDateFormat("MM-dd-yyyy").format(Date()) }
174 )).build()
175 }
176 }
177
178 override fun createTable() {
179 val sql = """
180 CREATE TABLE IF NOT EXISTS tags (
181 tagKey TEXT NOT NULL,
182 tagValue TEXT NOT NULL,
183 ownerID TEXT NOT NULL,
184 guildID TEXT NOT NULL,
185 UNIQUE (tagKey, guildID) ON CONFLICT ABORT,
186 CHECK (length (tagKey) != 0 AND length (tagValue) != 0)
187 );
188 PRAGMA auto_vacuum = FULL;
189 """
190
191 connect().createStatement().execute(sql)
192 }
193
194 override fun insert(mode: SQLItemMode, vararg args: String?) {
195 val sql = "INSERT INTO tags(tagKey, tagValue, ownerID, guildID) VALUES(?, ?, ?, ?)"
196 val connection = connect()
197 val preparedStatement = connection.prepareStatement(sql)
198 when (mode) {
199 LVALUE -> { with(preparedStatement) {
200 setString(1, args[0])
201 setString(2, args[1])
202 setString(3, args[2])
203 setString(4, args[3])
204 executeUpdate()
205 }
206 }
207 GVALUE -> { with(preparedStatement) {
208 setString(1, args[0])
209 setString(2, args[1])
210 setString(3, args[2])
211 setString(4, "GLOBAL")
212 executeUpdate()
213 }
214 }
215 else -> return
216 }
217 }
218
219 override fun select(mode: SQLItemMode, vararg args: String?) {
220 when (mode) {
221 ALL -> {
222 val sql = "SELECT * FROM tags"
223 val connection = connect()
224 val preparedStatement = connection.prepareStatement(sql)
225 val resultSet = preparedStatement.executeQuery()
226 tagCache.clear()
227 while (resultSet.next()) tagCache.add(Tag().set(
228 resultSet.getString("tagKey"),
229 resultSet.getString("tagValue"),
230 resultSet.getString("ownerID"),
231 resultSet.getString("guildID")
232 ))
233 }
234 LVALUE, GVALUE -> {
235 val sql = "SELECT tagValue FROM tags"
236 val connection = connect()
237 val preparedStatement = connection.prepareStatement(sql)
238 val resultSet = preparedStatement.executeQuery()
239 tagCache.clear()
240 while (resultSet.next())
241 for (t in tags) if (t.ownerID == resultSet.getString("tagValue")) tagCache.add(t)
242 }
243 else -> return
244 }
245 }
246
247 override fun delete(mode: SQLItemMode, vararg args: String?) {
248 val sql = "DELETE FROM tags WHERE tagKey = ? AND ownerID = ? AND guildID = ?"
249 val connection = connect()
250 val preparedStatement = connection.prepareStatement(sql)
251 when (mode) {
252 LVALUE -> {
253 preparedStatement.setString(1, args[0])
254 preparedStatement.setString(2, args[1])
255 preparedStatement.setString(3, args[2])
256 preparedStatement.executeUpdate()
257 }
258 GVALUE -> {
259 preparedStatement.setString(1, args[0])
260 preparedStatement.setString(2, args[1])
261 preparedStatement.setString(3, "GLOBAL")
262 preparedStatement.executeUpdate()
263 }
264 else -> return
265 }
266 }
267
268 override fun update(mode: SQLItemMode, vararg args: String?) {
269 val sql = "UPDATE tags SET tagValue = ? WHERE tagKey = ? AND ownerID = ? AND guildID = ?"
270 val connection = connect()
271 val preparedStatement = connection.prepareStatement(sql)
272 when (mode) {
273 LVALUE -> {
274 preparedStatement.setString(1, args[1])
275 preparedStatement.setString(2, args[0])
276 preparedStatement.setString(3, args[2])
277 preparedStatement.setString(4, args[3])
278 preparedStatement.executeUpdate()
279 }
280 GVALUE -> {
281 preparedStatement.setString(1, args[1])
282 preparedStatement.setString(2, args[0])
283 preparedStatement.setString(3, args[2])
284 preparedStatement.setString(4, "GLOBAL")
285 preparedStatement.executeUpdate()
286 }
287 else -> return
288 }
289 }
290
291 override fun exists(mode: SQLItemMode, vararg args: String?): Boolean {
292 val sql = "SELECT EXISTS(SELECT tagKey, guildID FROM tags WHERE tagKey = ? AND guildID = ?)"
293 val connection = connect()
294 val preparedStatement = connection.prepareStatement(sql)
295 return when (mode) {
296 LVALUE -> {
297 preparedStatement.setString(1, args[0])
298 preparedStatement.setString(2, args[1])
299 val resultSet = preparedStatement.executeQuery()
300 resultSet.getInt(1) == 1
301 }
302 GVALUE -> {
303 preparedStatement.setString(1, args[0])
304 preparedStatement.setString(2, "GLOBAL")
305 val resultSet = preparedStatement.executeQuery()
306 resultSet.getInt(1) == 1
307 }
308 else -> false
309 }
310 }
311
312 init {
313 name = "jagtag"
314 aliases = arrayOf("tag", "t")
315 category = Categories.GADGETS.category
316 arguments = "**<modifier>** **<name>** **<content>**"
317 help = "JagTag like in Spectra"
318 val db = File("C:\\Users\\Marvin\\IdeaProjects\\dclient\\src\\main\\resources\\PilotDB.sqlite")
319 if (!db.exists()) {
320 if (db.createNewFile()) {
321 createDatabase()
322 createTable()
323 }
324 } else {
325 select(ALL)
326 tags.addAll(tagCache)
327 }
328 }
329}