Compare commits

..
777 Commits
Author SHA1 Message Date
BenCodez f581ce26fb Update version number to 6.3 2021-04-25 13:53:14 -04:00
BenCodez 0cc06a0b1f Remove unused file 2021-04-25 12:45:31 -04:00
BenCodez 27dfa7e481 Improvements to interact event & more 2021-04-24 21:07:38 -04:00
BenCodez 0659fd8b84 Bug fix 2021-04-24 07:53:25 -04:00
BenCodez 8512eef6c0 Another little bug fix 2021-04-23 21:54:16 -04:00
BenCodez e860195847 Bug fix 2021-04-23 21:43:22 -04:00
BenCodez 3c34798d1a Fixed bug regarding help command permissions 2021-04-23 19:09:58 -04:00
BenCodez 1275a10de5 Add config option 2021-04-23 18:28:38 -04:00
BenCodez 99c2e9aa1f Fix broadcast handler 2021-04-22 16:56:16 -04:00
BenCodez d3b0787f90 Bug fix for /vote shop (item) command 2021-04-21 17:34:05 -04:00
BenCodez faad7d3b85 Little fix 2021-04-20 20:21:24 -04:00
BenCodez 099596fdde Add config option for geyser support 2021-04-20 17:34:33 -04:00
BenCodez ab202ffe1c Add option to trigger votifier event 2021-04-20 17:14:07 -04:00
BenCodez b935d7f578 Add alternate broadcast method 2021-04-19 18:54:09 -04:00
BenCodez d505d197ba Change default option 2021-04-18 14:38:38 -04:00
BenCodez 12c9aab745 Bug fix 2021-04-18 14:14:56 -04:00
BenCodez 3c10cb2340 Update to reward api changes 2021-04-17 21:54:52 -04:00
BenCodez f57cc3bc06 Add option to move backbutton to end of GUI 2021-04-14 19:22:19 -04:00
BenCodez eb4afec6db Undo placeholder change 2021-04-12 17:05:44 -04:00
BenCodez 35b4df196d Little change 2021-04-11 15:34:07 -04:00
BenCodez 038e8fb98a increase column size 2021-04-10 20:03:31 -04:00
BenCodez b84a14f849 Change top voter placeholder parsing 2021-04-09 17:02:09 -04:00
BenCodez eeda3875e4 Add option to disable player interact event 2021-04-09 16:52:41 -04:00
BenCodez a584a78734 Parse top voter placeholders as current player 2021-04-08 18:40:37 -04:00
BenCodez e408c07f85 Update version number 2021-04-07 17:01:28 -04:00
Ben 4700684f03 Fix yml error 2021-04-07 04:48:56 -04:00
BenCodez 8ef7631eed Add option to ignore can vote per votesite 2021-04-04 16:13:59 -04:00
BenCodez 825d736a58 Update version number 2021-04-04 14:29:22 -04:00
BenCodez b3f5aac192 Bug fix with cumulative remove 2021-04-04 14:22:07 -04:00
BenCodez e06b21d69c Check if bungee votifier event exists before enabling event 2021-04-04 12:27:12 -04:00
BenCodez 9dc3a99885 Add config options 2021-04-03 15:32:59 -04:00
BenCodez 18145b8340 Add missing config options 2021-04-03 15:32:01 -04:00
Ben f25bbf3437 Update stale.yml 2021-04-02 17:01:54 -04:00
BenCodez 2d53ae7452 Fix a few issues with reward GUI editing 2021-04-02 16:44:46 -04:00
BenCodez 0f67c0db36 Add missing classes from commit 2021-04-02 14:58:33 -04:00
BenCodez 436dc01edd Add ability to edit voteparty, milestones, cumulative & more via gui's 2021-04-02 14:53:02 -04:00
BenCodez a1bee2fa05 Remove unneeded maven dependency 2021-03-27 19:05:43 -04:00
BenCodez 78ab2de0e9 Update version number 2021-03-27 17:45:10 -04:00
BenCodez 76823d74f1 Add ability to edit voteshop rewards 2021-03-23 19:30:49 -04:00
BenCodez db51306ef9 Modify cooldown check handling 2021-03-21 19:36:08 -04:00
BenCodez b95f2beaf5 Add directly defined reward handling 2021-03-21 16:17:17 -04:00
BenCodez 7be07b0102 Increase message on bungee votes debug 2021-03-18 17:24:20 -04:00
BenCodez 6eeee7ca02 Disable VoteCoolDown background task by default if no rewards set 2021-03-18 17:19:58 -04:00
BenCodez 7bbddc9a8a Auto disable cooldown check if needed 2021-03-17 17:05:37 -04:00
BenCodez ac994ac864 Update version number 2021-03-14 12:51:20 -04:00
BenCodez 1aca211e71 Increase delay for cooldown check 2021-03-14 12:27:55 -04:00
BenCodez c7d0b09706 Little changes to addition 2021-03-13 21:56:22 -05:00
BenCodez 5999b778b3 Add option to delay login event 2021-03-13 21:53:40 -05:00
BenCodez 04d21ccb4e Additional little bug fix regarding bungee online/offline reward handles 2021-03-13 21:19:05 -05:00
BenCodez 3ba63bfaec Bug fix 2021-03-13 21:17:55 -05:00
BenCodez eeb7d3da1d Add option to disable cooldown check 2021-03-13 08:03:58 -05:00
BenCodez cfaae26c16 Bug fix 2021-03-12 16:33:23 -05:00
BenCodez 5806e6adad Change default value of config option 2021-03-10 19:10:41 -05:00
BenCodez 6718b49e49 Fix placeholders getting parsed when they shouldn't 2021-03-06 19:42:31 -05:00
BenCodez 403fe20f68 Update version number 2021-03-06 19:32:43 -05:00
BenCodez 2dd6ef4da5 Add config option 2021-03-06 15:29:48 -05:00
BenCodez 42fd72723d Add option to change backbutton to voteurl 2021-03-06 14:18:44 -05:00
BenCodez 8ea599d739 Add try/catch as failsafe 2021-03-04 17:03:38 -05:00
BenCodez 104baa80eb Add /av resetmilestonecount 2021-03-03 16:50:11 -05:00
BenCodez 9c700268a6 Bug fix 2021-03-02 20:29:38 -05:00
BenCodez e158f43c11 Remove config option for storing monthly votes, always store montly top 2021-03-01 19:25:03 -05:00
BenCodez 617f8a9a7d Add class 2021-03-01 19:10:38 -05:00
BenCodez 63edc5bf4f Implement bungee version 2021-03-01 19:09:45 -05:00
BenCodez 492dca7a22 Add option 2021-02-28 10:50:47 -05:00
BenCodez 69a6485317 Add option to disable clicking top voters skulls opening VoteGUI 2021-02-28 10:50:11 -05:00
BenCodez 1b75dfb886 Add ability to edit voteshop with GUI's 2021-02-27 20:42:09 -05:00
BenCodez 652deabf83 Fix issue with votedelay not being able to be 0 2021-02-24 18:54:10 -05:00
BenCodez 1c4b0c687b Add different text colors for voteurl sites 2021-02-24 17:01:25 -05:00
BenCodez 80455d68e2 Update version number 2021-02-21 14:31:00 -05:00
BenCodez 0d8dd6eb60 Changes to allsites reward checks 2021-02-21 13:52:31 -05:00
BenCodez 7cfd3e5a94 Fix hidden votesite option, a lot of other fixes from recent changes 2021-02-21 13:44:46 -05:00
BenCodez 46d9b07db3 Modify voteurl a little more 2021-02-20 17:39:56 -05:00
BenCodez ac4f5a4b02 Modify VoteURL to be more configurable 2021-02-20 17:35:08 -05:00
BenCodez 5bfa59508a Keep bungee from failing to load on bungee without votifier 2021-02-20 17:16:57 -05:00
BenCodez 9d53af3059 Organize config file 2021-02-17 19:33:40 -05:00
BenCodez 82c32c6ed1 Little fix for spigot setting totals on bungee methods 2021-02-17 19:12:15 -05:00
BenCodez af5b4231c2 Add option for what server handles totals 2021-02-17 19:11:08 -05:00
BenCodez 00c1830ced Add option to hide votesites 2021-02-17 18:37:00 -05:00
BenCodez 335888d0ad Add option for extra allsites check, works per server 2021-02-15 17:19:27 -05:00
BenCodez 397f71020c Modify yml error messages 2021-02-14 12:49:35 -05:00
BenCodez 31ea9f8413 Add WaitForUserOnline, modify bungee handling 2021-02-13 21:12:16 -05:00
BenCodez bfcbcb8802 Broadcast on force voteparty command 2021-02-13 13:40:20 -05:00
BenCodez 30bf07edc7 Actually set per server rewards option 2021-02-12 18:50:41 -05:00
BenCodez be3de852ce Add per server rewards option 2021-02-12 18:49:28 -05:00
BenCodez d9f3c4a465 Add bypass option for votifier 2021-02-12 17:53:16 -05:00
BenCodez b3c3a30ea4 Bug fix 2021-02-11 20:39:33 -05:00
BenCodez f785b1256d Bug fix 2021-02-11 20:13:48 -05:00
BenCodez 5b4d93197c Update version number 2021-02-07 13:41:40 -05:00
BenCodez d1d159ba90 Modify socket method to work more like pluginmessaging 2021-02-07 13:13:56 -05:00
BenCodez 8501c351dd Background check votes on bungee 2021-02-06 21:45:01 -05:00
BenCodez a61d8bbd04 Ignore votes from votifier when using bungeemethod pluginmessaging 2021-02-06 19:04:11 -05:00
BenCodez ccd39ebc89 Permission fixes 2021-02-06 15:57:32 -05:00
BenCodez da04ddad7d Improve status command to show blocked servers 2021-02-05 22:13:03 -05:00
BenCodez 498210d709 Bungee change 2021-02-05 21:53:30 -05:00
BenCodez c128bec2af Add ability to execute rewards on clicking vote gui 2021-02-05 19:32:02 -05:00
BenCodez 84ce9275f0 Little change to help with perms 2021-02-04 16:47:35 -05:00
BenCodez 66bdd9b5c7 Add option 2021-02-03 18:32:23 -05:00
BenCodez b02ab916cd Store all top voters on top voter storing 2021-02-02 19:23:44 -05:00
BenCodez a2068da36b Update spigot api version 2021-02-01 17:42:09 -05:00
BenCodez 83c43331a9 Update version number 2021-02-01 17:02:59 -05:00
BenCodez afe68ef229 Little change 2021-02-01 16:53:45 -05:00
BenCodez 7eec56ee2a Changed to top voter file storing 2021-02-01 16:49:10 -05:00
BenCodez 2ed462b61c Little change for default value 2021-01-31 12:31:34 -05:00
Ben dd142d20fe Merge pull request #1106 from Gadsee/patch-1
Prevent clients from sending plugin messages
2021-01-30 21:48:05 -05:00
Gadsee 8a340dc292 Add missing import 2021-01-31 03:21:05 +01:00
Deko e77201613e Prevent clients from sending plugin messages
Clients can send data over the plugin message channels the same way servers can. Canceling the event and returning if the message was not sent by the Server fixes the issue.
In the worst case scenario, the server will crash if the client sends invalid data, due to how this plugin attempts to continually load the message.
2021-01-31 03:15:20 +01:00
BenCodez 710ad17f47 Update version number 2021-01-30 20:06:58 -05:00
BenCodez a617625b87 Improve status command for pluginmessaging 2021-01-30 18:06:50 -05:00
BenCodez e8a5319544 Changes to bungee messaging, weekly voteparty reset 2021-01-30 17:34:24 -05:00
BenCodez 86e737892a Little fix for vote party reset count 2021-01-28 16:43:40 -05:00
BenCodez 3fd7a40421 Remove unneeded check 2021-01-27 17:05:20 -05:00
BenCodez a70e5aa54c Add option to not reset vote party total 2021-01-26 16:56:13 -05:00
BenCodez 593aae1e67 Fix issue with no player names 2021-01-26 16:52:38 -05:00
BenCodez e88849854b Bug fix 2021-01-26 16:47:52 -05:00
BenCodez 738fd5645e Change warning messages for votesite display item & service site issue 2021-01-24 20:36:10 -05:00
BenCodez 22ac364f8a Add option 2021-01-24 14:15:46 -05:00
BenCodez 5d78d3a734 Change debug values 2021-01-24 14:11:26 -05:00
BenCodez e83b12a248 Add ability for vote party once a day only 2021-01-23 20:45:08 -05:00
BenCodez 0f50998519 Update version number to 6.1 2021-01-23 18:01:37 -05:00
BenCodez 1768d4490f Command changes 2021-01-23 17:42:21 -05:00
BenCodez 2a3635b805 Add option to main vote gui run on /vote 2021-01-23 16:41:59 -05:00
BenCodez a5be973fd4 Fix back to main GUI button 2021-01-22 21:04:02 -05:00
BenCodez c8a76f38f9 Votetoday back button to votegui bug fix 2021-01-22 20:30:20 -05:00
BenCodez 273edaf101 Little bug fix 2021-01-22 19:12:54 -05:00
BenCodez d1a90676fc Changes to /av perms 2021-01-19 19:40:43 -05:00
BenCodez ff6119050d Add nonvotedplayerscache, allows allowunjoined option on bungee 2021-01-18 17:44:00 -05:00
BenCodez 0a0b95097d Changes to month/week/day changes to reduce impact of server restarts 2021-01-17 16:21:13 -05:00
BenCodez ace42a5a1f Little fixes 2021-01-13 17:11:25 -05:00
BenCodez 1a23648b91 Add package relocation to prevent conflicts 2021-01-09 14:50:00 -05:00
BenCodez 65b5a46525 Changes to permission handling, advanced tab is disabled 2021-01-08 17:34:54 -05:00
BenCodez 462d99c0e5 Little change 2021-01-04 18:57:23 -05:00
BenCodez 04636dd5af Little change 2021-01-03 12:29:38 -05:00
BenCodez d5b5b6cec0 Command changes 2021-01-02 16:47:08 -05:00
BenCodez 921fdac8bb Little change 2020-12-27 17:09:34 -05:00
BenCodez 6b9bc60785 Bug fix 2020-12-27 16:51:25 -05:00
BenCodez ff01c73193 Little changes 2020-12-26 09:14:59 -05:00
BenCodez a6cb4c3a8c Bug fix 2020-12-25 12:43:32 -05:00
BenCodez 43d33277ba Little fix 2020-12-25 11:41:12 -05:00
BenCodez 9badb50075 Little change 2020-12-22 19:44:29 -05:00
BenCodez ad6a09ba85 Bug fix 2020-12-22 16:58:55 -05:00
BenCodez 1791ec5e46 Merge branch 'master' of https://github.com/BenCodez/VotingPlugin 2020-12-22 16:57:24 -05:00
BenCodez 46457a9e61 Update version number 2020-12-22 16:56:23 -05:00
Ben 38ab221fd8 Little bug fix 2020-12-22 05:39:59 -05:00
BenCodez fc2317655e Change default option 2020-12-21 20:12:52 -05:00
BenCodez fb183b9f1f Add option 2020-12-21 18:40:49 -05:00
BenCodez 64057723b6 Update version number 2020-12-19 17:51:20 -05:00
BenCodez 703662c0c0 Bug fix 2020-12-19 17:51:01 -05:00
BenCodez ac72b47362 Update version number 2020-12-19 16:57:43 -05:00
BenCodez 6ca0e26e9c Add per shop message for purchases 2020-12-19 16:45:59 -05:00
BenCodez 168f2fbce2 Improvements 2020-12-17 19:21:51 -05:00
BenCodez a45370011e Little change 2020-12-14 16:58:21 -05:00
BenCodez f85c97f50a Bug fix 2020-12-09 17:14:01 -05:00
BenCodez 1651f8b626 Add option 2020-12-08 21:27:31 -05:00
BenCodez ad08e4cfcf Little fix 2020-12-06 12:08:17 -05:00
BenCodez 91ec3456f5 Little change 2020-12-06 12:02:36 -05:00
BenCodez 4c4f0ef6ae Add per vote shop purchase confirmations 2020-11-30 19:04:51 -05:00
BenCodez 17a899407d Update version number 2020-11-27 20:46:01 -05:00
BenCodez 1a194c684d Little change 2020-11-27 17:03:01 -05:00
BenCodez 93e06e431d Bug fix 2020-11-26 16:47:06 -05:00
BenCodez 8fede65b79 Little change 2020-11-25 21:23:44 -05:00
BenCodez 601d23d5cc Undo 2020-11-25 20:50:38 -05:00
BenCodez 536bacb96a Deprecate class 2020-11-25 19:55:39 -05:00
BenCodez 07b4c36490 Temp change to support plugins until update 2020-11-25 19:51:08 -05:00
BenCodez 39a86b824e Change default option 2020-11-24 19:01:04 -05:00
BenCodez 204c17affc Bug fix 2020-11-24 18:58:54 -05:00
BenCodez ff92dccf47 Bug fix 2020-11-24 18:54:50 -05:00
BenCodez ec69a4db70 Bug fix 2020-11-24 17:08:48 -05:00
Ben c9e0880ce9 Update README.md 2020-11-23 17:48:28 -05:00
BenCodez 8b03792a52 Bug fix 2020-11-23 17:04:08 -05:00
BenCodez 42d9f413f5 Little changes 2020-11-22 15:14:34 -05:00
BenCodez fdb8a86def Javadoc fixes 2020-11-22 14:56:35 -05:00
BenCodez b54cda1834 Little changes 2020-11-22 14:41:03 -05:00
BenCodez 824a740c96 Little change 2020-11-22 13:59:47 -05:00
Ben 63ed67b137 Merge pull request #1042 from BenCodez/6.0
6.0
2020-11-22 13:53:31 -05:00
BenCodez 6fd008e1a8 Update version number 2020-11-22 13:19:38 -05:00
BenCodez 13afac8da2 Bug fixes 2020-11-22 13:09:38 -05:00
BenCodez 31565f20fb Little change 2020-11-21 21:05:00 -05:00
BenCodez d4abcec817 Add options 2020-11-21 18:39:22 -05:00
BenCodez 6675f12205 Add bungee metrics 2020-11-18 21:12:23 -05:00
BenCodez 66d2903ff5 Little changes 2020-11-17 18:49:30 -05:00
BenCodez fffeea6435 Little changes 2020-11-16 20:24:32 -05:00
BenCodez b9ae8b8c6f Add ability to inject custom commands 2020-11-15 16:08:23 -05:00
BenCodez 974029523e Change user class name 2020-11-15 13:48:45 -05:00
BenCodez 70abbcc119 Little changes 2020-11-14 20:06:21 -05:00
BenCodez 927be61e93 Change package names 2020-11-14 19:06:43 -05:00
BenCodez 8a3341e7b9 Little changes 2020-11-10 16:39:48 -05:00
BenCodez e3ace6cf12 Add primary account support for /vote 2020-11-09 19:22:17 -05:00
BenCodez b84f230179 Little changes 2020-11-09 17:13:46 -05:00
BenCodez e2fd7347b4 Changed to primary account 2020-11-09 17:08:51 -05:00
BenCodez 223ba96a95 A lot of improvements 2020-11-07 21:56:27 -05:00
BenCodez 766efe0cda Little changes 2020-11-05 20:03:40 -05:00
BenCodez ab792de3c7 Little change 2020-11-04 20:35:03 -05:00
BenCodez 7807ef6d88 Update to 1.16.4, readd mvdwplaceholders 2020-11-04 17:16:45 -05:00
BenCodez ba7407cca6 Little fix 2020-11-02 21:35:33 -05:00
BenCodez b83249187e Command changes for /av placeholders 2020-11-02 21:34:16 -05:00
BenCodez 2b22e7ea6f Bug fix 2020-11-01 15:27:28 -05:00
BenCodez 86b18f3bea Bug fix 2020-11-01 15:19:21 -05:00
BenCodez f3c844b2f8 Attempted bug fix 2020-11-01 15:09:26 -05:00
BenCodez 53568b6c6f Add debug info to bungee votes 2020-11-01 12:33:23 -05:00
BenCodez 35b034b9e7 Changes to milestone handling 2020-11-01 12:24:50 -05:00
BenCodez 45367d59d2 Little change 2020-10-31 19:26:22 -04:00
BenCodez 1ded5a4369 Add ability to customize vote shop confirmation GUI 2020-10-30 19:40:11 -04:00
BenCodez 940f9a5662 Little fixes 2020-10-30 16:53:49 -04:00
BenCodez 319d4ead82 Bug fix 2020-10-29 16:39:01 -04:00
BenCodez cd87ccf6ff Bug fix 2020-10-28 21:28:29 -04:00
BenCodez 9604c6c156 Test change 2020-10-27 19:44:15 -04:00
BenCodez 5b47d1b198 Bug fix 2020-10-27 16:59:03 -04:00
BenCodez 97d265045c Bug fix 2020-10-27 16:57:07 -04:00
BenCodez ce508c4009 More little changes 2020-10-26 17:00:00 -04:00
BenCodez 8094e8acec Bug fix 2020-10-26 16:45:52 -04:00
BenCodez 2d2cfe8ccf Changes 2020-10-25 21:14:31 -04:00
BenCodez cb6d17c6e3 Bug fix 2020-10-24 21:39:28 -04:00
BenCodez 1811e18420 Remove old jars/convert commands 2020-10-24 21:37:03 -04:00
BenCodez 964aeef138 Fix repeat milestones not working 2020-10-24 18:53:18 -04:00
Ben12345rocks 524d001c28 Add placeholder, closes #992 2020-10-20 20:33:07 -04:00
Ben12345rocks 976a8f4f62 Add login/logout rewards 2020-10-18 15:39:36 -04:00
Ben12345rocks b30ea9c7d3 Bug fix for cumulative 2020-10-16 21:22:13 -04:00
Ben12345rocks ae60182cd7 Add ability to keep voteshop open 2020-10-14 19:24:27 -04:00
Ben12345rocks b28cfac096 Fix spelling mistake 2020-10-14 19:12:15 -04:00
Ben12345rocks 4b93353022 Attempt cumulative fix 2020-10-14 17:19:22 -04:00
Ben12345rocks 7715b3d66d Bug fix 2020-10-13 20:56:05 -04:00
Ben12345rocks 5fbecec78b Bug fix 2020-10-13 20:27:06 -04:00
Ben12345rocks 64f15a1bf2 Fix typo 2020-10-13 20:11:23 -04:00
Ben12345rocks 9ab08c22be Bug fix 2020-10-13 19:58:49 -04:00
Ben12345rocks f29e4d99ba Little changes 2020-10-12 20:47:27 -04:00
Ben12345rocks fdb53d550e Move GUI settings to GUI.yml 2020-10-11 20:36:38 -04:00
Ben12345rocks c2ac312522 Implement new command handling for GUI's 2020-10-11 19:19:08 -04:00
Ben12345rocks c87b5e5728 Add build profiles 2020-10-07 20:55:03 -04:00
Ben12345rocks 1eeea835aa Add count offline vote party votes option 2020-10-07 17:07:34 -04:00
Ben12345rocks cf6a6200ca Reduce number of queries 2020-10-06 17:26:08 -04:00
Ben12345rocks 885ec12d88 Update version number 2020-10-05 16:56:47 -04:00
Ben12345rocks c23911b14a Bug fix 2020-10-04 12:55:57 -04:00
Ben12345rocks da9a5b88aa Bug fix 2020-10-03 20:52:11 -04:00
Ben12345rocks d96490e60b Update version number 2020-10-03 20:18:55 -04:00
Ben12345rocks 2198c5d4a0 Bug fix 2020-10-03 20:13:31 -04:00
Ben12345rocks 776179e41d Little improvements 2020-10-03 19:31:14 -04:00
Ben12345rocks 7bda38ff48 Little improvement 2020-10-03 07:56:09 -04:00
Ben12345rocks a23ead4d9c Little command improvement 2020-10-02 19:42:37 -04:00
Ben12345rocks 0f820738c6 Add safe guard for milestones with config option 2020-10-02 19:14:52 -04:00
Ben12345rocks 30d912114d Improvements to book GUI 2020-09-29 19:45:04 -04:00
Ben12345rocks 567288309c Bug fix 2020-09-29 17:22:12 -04:00
Ben12345rocks 7cd67f55f1 Little improvement 2020-09-29 16:44:52 -04:00
Ben12345rocks 59e7dcd8e8 Bug fix and little improvements 2020-09-28 19:21:54 -04:00
Ben12345rocks 90e55a0a7d Add command /av resyncmilestonesalreadygiven 2020-09-25 20:04:25 -04:00
Ben12345rocks a280d91c05 Add book GUI for /vote 2020-09-24 19:27:21 -04:00
Ben12345rocks feb54aeb9e Undo test commit 2020-09-20 13:24:06 -04:00
Ben12345rocks ee96bf500e Test commit 2020-09-20 13:23:26 -04:00
Ben12345rocks 91a266889f Code cleanup 2020-09-20 12:39:59 -04:00
Ben12345rocks 6051138613 Test change 2020-09-14 17:03:17 -04:00
Ben12345rocks d9780f9954 Add a command to force top voter awards 2020-09-13 14:23:31 -04:00
Ben12345rocks 453287dc1c Fix logging votes to file 2020-09-12 18:23:21 -04:00
Ben12345rocks 8f119862d0 Update to 1.16.3 2020-09-10 19:22:46 -04:00
Ben12345rocks df1fc4a734 Little change 2020-09-07 14:51:35 -04:00
Ben12345rocks a545462410 Update version number 2020-09-06 20:01:13 -04:00
Ben12345rocks bb7cc4d6e7 Change default config option 2020-09-05 18:24:01 -04:00
Ben12345rocks eb69cf41a5 Add config options 2020-09-05 16:22:59 -04:00
Ben12345rocks 642164b1b4 Little fix 2020-09-03 16:29:38 -04:00
Ben12345rocks ff99a462d7 Add /av user (player) ForceVoteShop (Shop) 2020-09-03 16:27:56 -04:00
Ben12345rocks e7de87e8aa Merge branch 'master' of https://github.com/Ben12345rocks/VotingPlugin 2020-09-03 15:17:46 -04:00
Ben12345rocks e5d91037cb Bug fix 2020-09-03 15:16:47 -04:00
Ben e7db5b8aa2 Merge pull request #937 from DrBot7/master
More reminding options
2020-09-03 15:13:02 -04:00
DrBot7 551c962cd2 More reminding options
With this change, players with the votingplugin.login.remindvotes.any permission will be reminded to vote as long as they can vote on any of their voting sites.
2020-09-02 23:33:39 -05:00
Ben12345rocks 5ada4e05a2 Bug fix 2020-09-01 15:22:52 -04:00
Ben12345rocks 1f3243e362 Bug fix 2020-08-31 15:10:06 -04:00
Ben12345rocks 303b944128 Update version number 2020-08-29 20:38:21 -04:00
Ben12345rocks 989e8fd7a2 Bug fixes 2020-08-29 19:46:53 -04:00
Ben12345rocks 9a21e37516 Bug fix 2020-08-29 19:16:09 -04:00
Ben12345rocks 29a27477b6 Implement config changes 2020-08-29 19:03:47 -04:00
Ben12345rocks 0ebc5a4c6e More improvements 2020-08-27 15:50:05 -04:00
Ben12345rocks 1c6131589f Little change 2020-08-27 15:13:49 -04:00
Ben12345rocks a183335df7 Add info on real vote to bungee voting 2020-08-25 16:37:30 -04:00
Ben12345rocks c0447ab6e0 Add http to urls if forcing 2020-08-25 16:23:33 -04:00
Ben12345rocks 0c9c2dacfa Update version number 2020-08-23 13:26:39 -04:00
Ben12345rocks 48dbd26d24 Improvements 2020-08-23 13:19:38 -04:00
Ben12345rocks 65de370539 Add top placeholder 2020-08-23 12:14:28 -04:00
Ben12345rocks 1ffb050939 Add voteshop disabled message to config 2020-08-22 17:22:15 -04:00
Ben12345rocks 0f15c69831 Bug fix 2020-08-22 15:27:51 -04:00
Ben12345rocks 5d99ea6154 Add placeholder 2020-08-22 14:57:11 -04:00
Ben12345rocks 7224cb76de Bug fix 2020-08-17 15:55:34 -04:00
Ben12345rocks 1ac9df057d Bug fix 2020-08-16 17:54:39 -04:00
Ben12345rocks 033941388c Bug fix 2020-08-16 17:50:42 -04:00
Ben12345rocks fc979bc6bf Bug fix 2020-08-16 17:34:09 -04:00
Ben12345rocks f1860f2934 Use config option 2020-08-16 13:44:55 -04:00
Ben12345rocks ab8696a3a4 Bug fix 2020-08-16 13:28:31 -04:00
Ben12345rocks 09cd00a563 Bug fix 2020-08-16 12:56:11 -04:00
Ben12345rocks f2ca7c3240 Add placeholder 2020-08-16 12:39:31 -04:00
Ben12345rocks 6928c15147 Bug fixes 2020-08-16 12:15:27 -04:00
Ben12345rocks 9e278de881 Fix spelling mistake 2020-08-15 20:02:52 -04:00
Ben12345rocks af9e207012 Update version number 2020-08-15 19:20:53 -04:00
Ben12345rocks c667a6ba56 Improvements 2020-08-15 19:18:50 -04:00
Ben12345rocks 37c6888962 Improvements 2020-08-15 18:52:33 -04:00
Ben12345rocks 5729968630 Bug fix 2020-08-15 15:21:48 -04:00
Ben 5fb377da21 Merge pull request #902 from DrBot7/patch-1
Fix vnext
2020-08-13 16:50:00 -04:00
DrBot7 92f0c284cd Fix vnext
The current state with build 325 is telling me that I can't vote even though I can.
https://imgur.com/a/ueRrMao
I noticed that MCMP, which has a daily timer with no offset, tells me that I am able to vote in 8 hours. However, I should be able to vote now. I wrote up some code and tested locally. This seems to have fixed my issue.
2020-08-13 15:43:50 -05:00
Ben12345rocks 7c8be94d88 Bug fix 2020-08-13 15:43:36 -04:00
Ben12345rocks 19690712ba Bug fix 2020-08-12 19:28:16 -04:00
Ben12345rocks 7c32a0c883 Bug fix 2020-08-12 17:08:57 -04:00
Ben12345rocks df87848caa Another change 2020-08-12 17:05:56 -04:00
Ben12345rocks 534253fbfc Bug fix 2020-08-12 16:43:15 -04:00
Ben12345rocks afbbbcfd45 Code cleanup 2020-08-12 15:22:54 -04:00
Ben12345rocks f5ea7e8490 Bug fix 2020-08-12 15:21:52 -04:00
Ben12345rocks c0b1c82ec4 Little performance improvement 2020-08-11 19:33:10 -04:00
Ben12345rocks 99eb028a62 Update to 1.16.2 2020-08-11 19:13:11 -04:00
Ben12345rocks ce3a40a155 Little change 2020-08-11 19:06:16 -04:00
Ben12345rocks da5e71a614 Bug fix 2020-08-11 17:28:41 -04:00
Ben12345rocks c2e509e4c7 Bug fix 2020-08-11 17:19:00 -04:00
Ben12345rocks a068c0b1db Bug fix 2020-08-11 16:25:05 -04:00
Ben12345rocks b1fa69ed26 Little improvements 2020-08-10 20:24:27 -04:00
Ben12345rocks d91f485f1e Little improvements 2020-08-10 15:39:27 -04:00
Ben12345rocks 0252dd3535 Improvements 2020-08-09 12:53:45 -04:00
Ben12345rocks 21cf18f34e Little change 2020-08-08 20:30:27 -04:00
Ben12345rocks 892cae605b A lot of bungee improvements 2020-08-08 19:32:53 -04:00
Ben12345rocks c97fd708e0 Add more log info for bungee 2020-08-07 21:58:28 -04:00
Ben12345rocks 12dd52af3d Add another method to bungee voting, untested 2020-08-07 20:22:48 -04:00
Ben12345rocks 3a3d784d6d Bug fix 2020-07-24 15:25:12 -04:00
Ben12345rocks 86c98ccae1 Bug fix 2020-07-23 15:18:42 -04:00
Ben12345rocks e004121081 Little change 2020-07-19 19:14:40 -04:00
Ben12345rocks 27c3bf71ec Undo changes 2020-07-19 16:57:38 -04:00
Ben12345rocks c5da78712f Little change 2020-07-19 16:11:29 -04:00
Ben12345rocks 7cd12844fd Little change 2020-07-19 14:50:09 -04:00
Ben12345rocks f04d03fa90 Little fix 2020-07-19 14:27:01 -04:00
Ben12345rocks 10af3797d1 Little change 2020-07-19 12:28:15 -04:00
Ben12345rocks 5dd9de8310 Bug fix 2020-07-14 15:49:58 -04:00
Ben12345rocks 75c7b6b703 Change Item to DisplayItem to avoid confusion 2020-07-12 13:23:32 -04:00
Ben12345rocks 70ef27deb8 Some improvements 2020-07-12 12:07:40 -04:00
Ben12345rocks 007f2e7b73 Bug fix 2020-07-09 15:25:18 -04:00
Ben12345rocks f7cafaefdc Little more improvements 2020-07-08 15:19:38 -04:00
Ben12345rocks cb6e27e700 Little config change 2020-07-08 15:10:20 -04:00
Ben12345rocks fd5ba1f98e Add option to use an item instead of skull for vote today 2020-07-07 15:39:01 -04:00
Ben12345rocks e63fd4d79c Improvements 2020-07-06 17:05:00 -04:00
Ben12345rocks be2a7e2ee3 Add command for current plugin time 2020-07-04 14:50:52 -04:00
Ben12345rocks 85a8a29e69 Add option to clear cache for vote shop 2020-07-03 08:06:51 -04:00
Ben12345rocks b07fe783dd Improve bungee efficiency 2020-06-27 20:43:48 -04:00
Ben12345rocks 75e4f45e9f Little change 2020-06-26 16:24:33 -04:00
Ben12345rocks 826d353bfd Update version number 2020-06-25 19:26:22 -04:00
Ben12345rocks 2891607947 Update to 1.16.1 2020-06-24 21:15:05 -04:00
Ben12345rocks b7a4955766 Separate bungee debug 2020-06-20 08:42:42 -04:00
Ben12345rocks d1f7c78bbe Bug fix 2020-06-20 08:05:34 -04:00
Ben12345rocks 289980aa41 Improve debugging for sockets 2020-06-19 16:39:32 -04:00
Ben12345rocks 217d1b60a3 Bug fix 2020-06-14 12:12:09 -04:00
Ben12345rocks fce1b38a24 Bug fix 2020-06-11 16:45:32 -04:00
Ben12345rocks 6538465add Maven updates 2020-06-07 17:13:17 -04:00
Ben12345rocks a70b9e46a8 Change default color codes for /vote 2020-06-06 18:17:03 -04:00
Ben12345rocks 22d7c75261 Add bungee help command 2020-06-05 19:24:56 -04:00
Ben12345rocks 1cdf7a1033 Bug fix 2020-06-03 16:21:47 -04:00
Ben12345rocks 27afaf8e1b Add bungee status command 2020-06-01 19:35:14 -04:00
Ben12345rocks 019699ae75 Bug fix 2020-06-01 18:58:19 -04:00
Ben12345rocks 745df69024 Add a status command for bungee voting 2020-06-01 17:38:35 -04:00
Ben12345rocks 6e84130261 Little improvement 2020-05-31 14:01:16 -04:00
Ben12345rocks 124485b4f0 Little imrprovement 2020-05-31 12:26:03 -04:00
Ben12345rocks f6f9028680 Little improvement 2020-05-31 12:09:42 -04:00
Ben12345rocks 7fab7c5ca8 Add config option for vote shop 2020-05-30 15:34:53 -04:00
Ben12345rocks 355bcfa4d1 Fix perm 2020-05-29 18:50:46 -04:00
Ben12345rocks 87715a1e93 Add command to clear points 2020-05-29 18:49:42 -04:00
Ben12345rocks cf5faca040 Little fix 2020-05-28 21:25:54 -04:00
Ben12345rocks 099ceb3bca Improvement 2020-05-28 20:19:30 -04:00
Ben12345rocks 56dd38b6e0 little change 2020-05-28 16:18:01 -04:00
Ben12345rocks ad752e024a Improvement 2020-05-27 19:05:54 -04:00
Ben12345rocks fc6f1052d6 Little improvement 2020-05-26 19:01:20 -04:00
Ben12345rocks f663b06626 Improvement 2020-05-23 20:17:32 -04:00
Ben12345rocks 7a38a4d7f8 Little improvement 2020-05-23 17:35:28 -04:00
Ben12345rocks 28b8c04f95 Bug fix 2020-05-23 17:30:05 -04:00
Ben12345rocks 85bc09c3da Little config change 2020-05-23 15:23:29 -04:00
Ben12345rocks b817ea25e6 Added persite level offset for /vote next only 2020-05-22 16:34:41 -04:00
Ben12345rocks 25ba2f597e Improve debug message 2020-05-22 16:25:49 -04:00
Ben12345rocks 321b3fbf3a Add option 2020-05-21 21:20:29 -04:00
Ben12345rocks df6a4e4a35 Bug fix 2020-05-17 21:34:23 -04:00
Ben12345rocks 7c0031b265 Bug fix 2020-05-16 16:14:12 -04:00
Ben12345rocks e99ec75a0f Update version number 2020-05-12 19:14:04 -04:00
Ben12345rocks 15f851e825 Bug fix 2020-05-12 17:36:46 -04:00
Ben12345rocks 0579e7a2fd Bug fix 2020-05-12 17:33:26 -04:00
Ben12345rocks 1c0b7dc0b1 Bug fix 2020-05-12 17:29:38 -04:00
Ben12345rocks 40d002fbfa Update version number 2020-05-10 12:27:37 -04:00
Ben e665eb668f Update stale.yml 2020-05-03 12:08:51 -04:00
Ben12345rocks 05239717a5 Bug fix 2020-05-01 16:22:07 -04:00
Ben12345rocks b91f9bedfa Bug fix 2020-04-26 13:19:46 -04:00
Ben12345rocks 12261ece0e Change default value 2020-04-23 16:20:28 -04:00
Ben12345rocks bef017c12d Added ForceLinks 2020-04-22 19:35:25 -04:00
Ben12345rocks a6544a399f Little change 2020-04-18 09:24:33 -04:00
Ben12345rocks 60b61ae49d Improvements 2020-04-14 18:09:11 -04:00
Ben12345rocks 93ccd5f392 Little change 2020-04-13 14:31:28 -04:00
Ben12345rocks 8169ed413c Add ability for voteshop confirmation 2020-04-13 11:12:44 -04:00
Ben12345rocks 1a42dfadc0 Little change 2020-04-13 11:00:15 -04:00
Ben12345rocks c5a5573652 Added voteshop limit resets 2020-04-13 10:58:58 -04:00
Ben12345rocks f7c3093478 Update version number 2020-04-12 12:25:29 -04:00
Ben12345rocks 6000e1fab9 Add config option 2020-04-10 17:50:24 -04:00
Ben12345rocks 2ac42539aa Bug fix 2020-04-10 15:32:14 -04:00
Ben12345rocks 6d25b02975 Little config improvement 2020-04-10 15:18:31 -04:00
Ben12345rocks f3582627fb Add broadcast blacklist 2020-04-10 15:17:13 -04:00
Ben12345rocks 9e98c2db78 Parse placeholderapi placeholders on broadcast 2020-04-10 13:44:02 -04:00
Ben12345rocks d387b632dd Bug fix 2020-04-04 15:06:47 -04:00
Ben12345rocks 69d4a49462 Bug fix 2020-04-04 08:30:31 -04:00
Ben12345rocks 5f648983c8 Attempted bug fix 2020-04-04 08:28:01 -04:00
Ben12345rocks d98bfd45fc Add another option 2020-04-03 16:49:32 -04:00
Ben12345rocks a38931ca23 Add option for gui 2020-04-02 16:52:48 -04:00
Ben12345rocks 508fcb2f29 Add votedelaymin 2020-04-01 20:03:56 -04:00
Ben12345rocks d280e4b131 Test change 2020-04-01 19:41:55 -04:00
Ben12345rocks 48c014227d Improvements 2020-04-01 16:56:54 -04:00
Ben12345rocks 21c4be4148 Little bug fix 2020-03-29 12:26:46 -04:00
Ben12345rocks d44290dcdc Update version number 2020-03-29 12:24:04 -04:00
Ben12345rocks 702c739ec8 Bug fix 2020-03-24 16:44:54 -04:00
Ben12345rocks c1122bd939 Bug fix 2020-03-23 20:40:53 -04:00
Ben12345rocks bdaa896fc1 Bug fix 2020-03-23 20:23:56 -04:00
Ben12345rocks 3b1c051fd2 Bug fix 2020-03-23 20:23:16 -04:00
Ben12345rocks 11194f819e Disable other background task when other one is enabled 2020-03-23 18:52:16 -04:00
Ben12345rocks 662eb16fdd Add log 2020-03-23 18:35:28 -04:00
Ben12345rocks d65070973c Add extra feature 2020-03-23 17:14:21 -04:00
Ben12345rocks cef41348cc Added message 2020-03-22 21:16:04 -04:00
Ben12345rocks bcba694308 Little change 2020-03-22 20:36:19 -04:00
Ben12345rocks fbd7c6d3fc Little improvements 2020-03-20 18:53:55 -04:00
Ben12345rocks f842c08d62 Add voteshop command 2020-03-20 17:51:55 -04:00
Ben12345rocks 4e58a6915f Update version number 2020-03-15 13:53:33 -04:00
Ben12345rocks 4336644fbc Bug fix 2020-03-14 19:19:41 -04:00
Ben12345rocks e32909ac58 Add softdepend 2020-03-14 18:31:06 -04:00
Ben12345rocks bd16e2ccaf Add command 2020-03-13 21:15:44 -04:00
Ben12345rocks 36fa55139e Bug fix 2020-03-13 17:08:23 -04:00
Ben12345rocks b128280d5f Silence error 2020-03-13 17:05:50 -04:00
Ben12345rocks 51e3f05031 Minor improvement 2020-03-11 20:02:04 -04:00
Ben12345rocks 19b83070c6 Improvements to config 2020-03-11 19:49:59 -04:00
Ben12345rocks 5622956e75 Added points formatted placeholder 2020-03-06 16:48:45 -05:00
Ben12345rocks 1ac3ea4916 Minor improvement to force commands 2020-03-06 16:45:14 -05:00
Ben12345rocks 391cc0edf1 Add advancedcore info to /av version 2020-03-01 14:15:11 -05:00
Ben12345rocks a59a98f8cb Update version number 2020-02-23 12:15:45 -05:00
Ben12345rocks e62213bfd5 Bug fix 2020-02-19 16:41:38 -05:00
Ben12345rocks 61b77c4754 Little improvement 2020-02-15 16:33:59 -05:00
Ben12345rocks 758aaa3dd7 Improvements 2020-02-15 16:24:22 -05:00
Ben12345rocks 51389a27fb Bug fix 2020-02-12 17:01:18 -05:00
Ben12345rocks 37b94cc36c Add console message on bungeecoord when vote received 2020-02-09 17:02:18 -05:00
Ben12345rocks 1e4796d418 Add option 2020-02-03 20:56:49 -05:00
Ben12345rocks 62b0d6012d Fix spelling mistake 2020-02-03 16:43:50 -05:00
Ben12345rocks 52726c8bb3 Fix warning message 2020-02-02 13:58:26 -05:00
Ben12345rocks ede06e0923 Fix warning message 2020-01-29 17:11:44 -05:00
Ben12345rocks 6eb2c95cc0 Change config comments 2020-01-26 12:16:32 -05:00
Ben12345rocks 835dff8620 Update version number 2020-01-21 17:03:12 -05:00
Ben12345rocks 1019b0b83b Update to 1.15.2 2020-01-21 16:59:12 -05:00
Ben12345rocks a44070b505 Bug fix 2020-01-19 12:39:14 -05:00
Ben12345rocks 58bd4e2d9d Little change 2020-01-17 16:45:07 -05:00
Ben12345rocks cff346e6a4 Add loadbefore 2020-01-13 16:54:18 -05:00
Ben 0331e34e91 Create stale.yml 2020-01-11 15:27:26 -05:00
Ben12345rocks 26ff8d8588 Add try/catch 2020-01-11 14:59:39 -05:00
Ben12345rocks 9a38826cf7 Improvement 2020-01-11 08:34:48 -05:00
Ben12345rocks b854631990 Little warning message 2020-01-04 11:44:07 -05:00
Ben12345rocks 5d1cd97ebd Update to 1.15.1 2019-12-17 19:42:34 -05:00
Ben12345rocks c21feb74d1 Update to 1.15 2019-12-10 18:57:25 -05:00
Ben12345rocks 052e2f2541 Update version number 2019-12-07 19:11:34 -05:00
Ben12345rocks 1270b57afa Add option to reset extra voteparty votes monthly and command to do so 2019-12-01 12:34:45 -05:00
Ben12345rocks cf8b219b9d Add ability to remove VotingPlugin.Player permission on a command 2019-11-27 20:27:14 -05:00
Ben12345rocks 689133aab8 Change default backbutton item to barrier 2019-11-23 19:45:57 -05:00
Ben12345rocks 019c0f01eb Add bungee communication encryption 2019-11-17 15:38:56 -05:00
Ben12345rocks 743cac217b Little improvement to bungee command 2019-11-03 17:07:59 -05:00
Ben12345rocks 5f19cb1ec8 Update version number 2019-11-02 21:08:21 -04:00
Ben12345rocks ac5ffa0f7c Bug fix 2019-10-31 17:20:40 -04:00
Ben12345rocks 114e07eb01 Improvements 2019-10-30 21:30:49 -04:00
Ben12345rocks 8ba1d75ab3 Bug fix 2019-10-30 20:30:59 -04:00
Ben12345rocks b3555918ed Improvements 2019-10-30 20:12:56 -04:00
Ben12345rocks 0759c05ed1 Bug fix 2019-10-29 21:35:26 -04:00
Ben12345rocks 278a8f70f2 Config improvements 2019-10-29 16:59:32 -04:00
Ben12345rocks fb5dc9923f Bug fix 2019-10-28 16:49:34 -04:00
Ben12345rocks f942505e62 Redo bungee system 2019-10-27 14:14:41 -04:00
Ben12345rocks 2d2b2db0a7 Bug fix 2019-10-27 12:52:40 -04:00
Ben 18d5078842 Update issue templates 2019-10-24 17:08:57 -04:00
Ben12345rocks 074b2c51e2 Another bug fix 2019-10-24 16:53:45 -04:00
Ben12345rocks 539194720a Possible bug fix 2019-10-24 16:50:06 -04:00
Ben 19fc5865fa Update issue templates 2019-10-20 15:51:09 -04:00
Ben f0d58e0c6a Update issue templates 2019-10-20 12:45:12 -04:00
Ben ddc2bea418 Update issue templates 2019-10-20 12:44:08 -04:00
Ben 24da6893ac Update issue templates 2019-10-20 12:39:37 -04:00
Ben12345rocks 7268017dc1 Javadoc fix 2019-10-19 20:22:30 -04:00
Ben12345rocks 4133480750 Update version number 2019-10-19 20:08:25 -04:00
Ben12345rocks 006a265c7a Improvements 2019-10-16 19:29:50 -04:00
Ben12345rocks 6850ef8a7d Improvements 2019-10-13 20:37:46 -04:00
Ben12345rocks 497f556ba6 Improvements 2019-10-13 19:21:38 -04:00
Ben12345rocks d62da744cd Add ability to disable commands 2019-10-12 17:08:20 -04:00
Ben12345rocks 864482e393 Bug fix 2019-10-12 15:27:12 -04:00
Ben12345rocks e41c25ed5d More bungeecoord improvements 2019-10-09 19:20:26 -04:00
Ben12345rocks 3e429b83a8 Bug fix 2019-10-09 17:01:03 -04:00
Ben12345rocks cd1af401ba Added config update command 2019-10-06 19:10:45 -04:00
Ben12345rocks 26e04bd890 Remove config update, requires more testing 2019-10-06 17:03:51 -04:00
Ben12345rocks b6d70fac9c Add config update to update config 2019-10-06 17:02:09 -04:00
Ben12345rocks 9e572c786c Add ability for plugin to run on bungeecoord, WIP 2019-10-06 15:00:53 -04:00
Ben12345rocks 4e44ce3ab8 Javadoc fix 2019-10-01 19:23:31 -04:00
Ben12345rocks 74c7fcb4da Update version number 2019-10-01 19:05:57 -04:00
Ben12345rocks ef64d52ad1 Extra safeguard 2019-10-01 17:39:34 -04:00
Ben12345rocks ab7bbec563 Add votes placeholder for top voter awards 2019-09-30 16:59:20 -04:00
Ben12345rocks 6afe4ab9d6 Use new message api 2019-09-29 12:58:59 -04:00
Ben12345rocks 12f43e3691 Add vote bossbar 2019-09-29 12:29:23 -04:00
Ben12345rocks 1e7cf2a1ba Add config option 2019-09-26 16:52:21 -04:00
Ben12345rocks 90636250cb Add ability to require allsites to be voted on for all urls button 2019-09-26 16:51:53 -04:00
Ben12345rocks 838451f956 Bug fix 2019-09-25 17:21:56 -04:00
Ben12345rocks cc85d999e1 New skull method for signs 2019-09-23 17:10:49 -04:00
Ben12345rocks 0013013cd2 Use new debug level 2019-09-21 21:07:05 -04:00
Ben12345rocks bfd04cf8a2 Update version number 2019-09-20 16:43:27 -04:00
Ben12345rocks beb1b70f50 Cleanup 2019-09-15 14:09:16 -04:00
Ben12345rocks f52edad583 Update version number 2019-09-15 13:54:58 -04:00
Ben12345rocks 0a1283de4b Small improvements 2019-09-14 20:59:07 -04:00
Ben12345rocks bed263aa87 Improvements 2019-09-14 07:54:46 -04:00
Ben12345rocks 55d8d20f88 Merge branch 'master' of https://github.com/Ben12345rocks/VotingPlugin 2019-09-13 17:39:10 -04:00
Ben12345rocks 3a59e2cdc2 Add new commands 2019-09-13 17:38:47 -04:00
Ben12345rocks 57fb754bc0 Add new option 2019-09-11 20:02:24 -04:00
Ben 052b48348b Merge pull request #617 from Shivelight/patch-1
Fix ToggleBroadcasts configuration path
2019-09-09 05:43:27 -04:00
Shivelight 5d15747c4e Fix ToggleBroadcasts configuration path
Match toggle broadcast message path with Config.java's path.
We are just fixing a typo here.
2019-09-09 16:04:12 +07:00
Ben12345rocks ce09359445 Improvement 2019-09-08 12:39:18 -04:00
Ben c22792bd9b Update README.md 2019-09-07 20:58:45 -04:00
Ben12345rocks 4ab36c355e Bug fix 2019-09-07 18:57:40 -04:00
Ben12345rocks 0b3829c1b4 Improvements 2019-09-07 18:56:05 -04:00
Ben12345rocks ae4883f099 Improvement 2019-09-07 18:13:29 -04:00
Ben12345rocks 2e3cf25e57 Add ability to set rewards with GUI 2019-08-25 13:07:51 -04:00
Ben12345rocks e65b831f35 Fix config typos 2019-08-18 12:38:54 -04:00
Ben12345rocks b6dc426eed Fix typo 2019-08-18 12:34:43 -04:00
Ben12345rocks a4f7619ca3 Update version number 2019-08-15 19:20:00 -04:00
Ben12345rocks 4e38dd0f1a Update version number 2019-08-11 13:23:08 -04:00
Ben12345rocks 2264db76cc Bug fixes 2019-08-11 13:22:17 -04:00
Ben12345rocks 28082abde5 Change option 2019-08-09 20:01:03 -04:00
Ben12345rocks 4814cfae86 Update version number 2019-08-04 13:25:27 -04:00
Ben12345rocks 3aa7820239 More messages 2019-08-04 13:04:23 -04:00
Ben12345rocks c4a7232bca Add last month GUI 2019-08-03 21:25:33 -04:00
Ben12345rocks ee390ac0b1 Bug fix 2019-08-01 19:06:58 -04:00
Ben12345rocks 187ee01d82 Add new abilities to vote shop 2019-08-01 17:00:27 -04:00
Ben12345rocks 64f3d89abb Bug fix 2019-07-31 20:55:38 -04:00
Ben12345rocks bc33cef53f Minor bug fix 2019-07-31 20:45:56 -04:00
Ben12345rocks 199936262a Add option 2019-07-29 20:13:26 -04:00
Ben12345rocks 3b6eb22c16 Improvements 2019-07-28 14:23:40 -04:00
Ben12345rocks 0dc2ada7bc Improvements 2019-07-27 19:45:31 -04:00
Ben12345rocks f591756697 Alert of yml error when reloading 2019-07-27 18:59:02 -04:00
Ben12345rocks 86175dc284 Minor improvements 2019-07-24 19:27:16 -04:00
Ben12345rocks d69970acdd Minor improvements 2019-07-21 21:23:27 -04:00
Ben12345rocks 8242c4a977 Minor fix 2019-07-20 14:54:58 -04:00
Ben12345rocks f319bce854 Add update check on plugin reload 2019-07-20 14:53:52 -04:00
Ben12345rocks 8bd1bfc3e0 Update spigot 2019-07-19 19:51:02 -04:00
Ben12345rocks cec3232b51 Add total placeholders for rewards 2019-07-11 20:40:43 -04:00
Ben12345rocks 7dcd892106 Keep certain inventories from always closing 2019-07-05 13:41:53 -04:00
Ben12345rocks 78ca13fcb7 Update version number 2019-07-04 08:53:04 -04:00
Ben12345rocks 48d37045d2 Cleanup 2019-07-04 08:44:08 -04:00
Ben12345rocks 92e4ec5ddb Bug fix 2019-07-04 08:22:25 -04:00
Ben12345rocks 6d760e2c5b Add way of detecting if votifier loaded properly 2019-07-03 21:46:15 -04:00
Ben12345rocks ee4eb6d86c Add validator 2019-07-03 20:18:08 -04:00
Ben12345rocks 44cea60852 Improvement 2019-07-03 20:04:40 -04:00
Ben12345rocks 4f68c6677e Improvements 2019-07-03 14:40:07 -04:00
Ben12345rocks 018aa632c9 Bug fix 2019-07-02 08:17:43 -04:00
Ben12345rocks ac1f19817f Add limit for month total 2019-07-01 14:56:32 -04:00
Ben12345rocks 365ece55b1 Move commands over 2019-06-30 19:34:15 -04:00
Ben12345rocks 8bbbfc6c7c Update to 1.14.3 2019-06-24 20:45:10 -04:00
Ben12345rocks 5fb3c34745 Bug fix 2019-06-22 21:12:05 -04:00
Ben12345rocks 8f32a7fed8 Bug fix 2019-06-21 21:18:29 -04:00
Ben12345rocks 6a9a48fa81 Bug fixes 2019-06-21 20:59:50 -04:00
Ben12345rocks 2cd3ddf7e0 Use new api 2019-06-21 20:56:14 -04:00
Ben12345rocks c110a53494 Move placeholder api to advancedcore 2019-06-10 19:06:28 -04:00
Ben12345rocks 944ef03f80 Fixed bug with /av help 2019-06-08 21:48:32 -04:00
Ben12345rocks 654ee73945 Update version number 2019-06-08 20:08:37 -04:00
Ben12345rocks b113a068fd Improve reward test 2019-06-08 19:46:53 -04:00
Ben12345rocks 216f9e878f Add test for rewards 2019-06-08 19:35:22 -04:00
Ben 3c1404c429 Update README.md 2019-06-06 19:48:18 -04:00
Ben12345rocks 80d7251540 Improvements 2019-06-05 20:07:24 -04:00
Ben12345rocks 5d4fa15a0b Bug fixes 2019-05-29 17:48:00 -04:00
Ben12345rocks 02258478bb Bug fix 2019-05-29 17:24:48 -04:00
Ben12345rocks c4274e30ff Update to 1.14.2 2019-05-27 19:14:46 -04:00
Ben12345rocks aade5c2a80 Add reward for when cooldown ended 2019-05-27 17:24:36 -04:00
Ben12345rocks a09113f2c6 Bug fix 2019-05-27 17:15:02 -04:00
Ben12345rocks d5cd6cd16a Bug fixes 2019-05-26 14:40:55 -04:00
Ben12345rocks fc7ad2a3ff Bug fix 2019-05-26 12:30:29 -04:00
Ben12345rocks 1539d4199c Add additional information on startup 2019-05-26 12:27:12 -04:00
Ben12345rocks bf4fc1cb56 Bug fix 2019-05-21 20:08:31 -04:00
Ben12345rocks 9bc2ec59e5 Bug fix 2019-05-21 19:18:32 -04:00
Ben12345rocks 32baf04a75 Bug fix 2019-05-21 19:05:05 -04:00
Ben12345rocks a62da35686 Bug fix 2019-05-21 18:06:16 -04:00
Ben12345rocks 7a9f409b59 Bug fix 2019-05-21 17:02:52 -04:00
Ben12345rocks 12c103e354 Remove deprecated code 2019-05-20 20:18:16 -04:00
Ben12345rocks cd62cbf576 Better debug for cooldown events 2019-05-20 19:51:52 -04:00
Ben12345rocks e550d93ca5 Little fix 2019-05-18 09:20:17 -04:00
Ben12345rocks 25effd4805 Add event for cooldown ending 2019-05-18 09:18:32 -04:00
Ben12345rocks bb6066d867 Remove ip lookup 2019-05-16 19:44:25 -04:00
Ben12345rocks c44f40afd0 Update to 1.14.1 2019-05-13 21:15:11 -04:00
Ben12345rocks fa677ace84 Improvements 2019-05-12 17:03:43 -04:00
Ben12345rocks 37e312a6d9 Javadoc fix 2019-04-26 17:13:15 -04:00
Ben12345rocks 1358e32470 Update version number 2019-04-26 17:08:00 -04:00
Ben12345rocks e08eddb0c0 Update version to 1.14 2019-04-25 20:10:22 -04:00
Ben12345rocks f7ac8b5fa4 Update to 1.14 2019-04-23 17:21:54 -04:00
Ben12345rocks 7d192be572 Add ability to match ip's ontop of service sites 2019-04-22 17:01:37 -04:00
Ben12345rocks 7984dec523 Bug fix 2019-04-22 16:53:57 -04:00
Ben12345rocks bb420bc709 Change default option for preloadskulls 2019-04-14 18:30:16 -04:00
Ben12345rocks 78b9a336d9 Some config comment improvements 2019-04-14 12:56:52 -04:00
Ben12345rocks 667a4ea749 Disable vote shop command if disabled 2019-04-13 08:39:05 -04:00
Ben12345rocks 4ede4ff88b Bug fix 2019-04-06 20:22:31 -04:00
Ben12345rocks e26043958a Add ability to disable gui clicking in /vote gui 2019-04-06 20:03:59 -04:00
Ben12345rocks d3a6c267c6 Bug fix 2019-03-24 17:32:26 -04:00
Ben12345rocks 0d92dfa563 Add placeholders for global totals 2019-03-23 15:57:18 -04:00
Ben12345rocks 6e9916fcbd Update version number 2019-03-18 19:16:47 -04:00
Ben12345rocks e81c3e27bc Little fix 2019-03-09 20:50:22 -05:00
Ben12345rocks f4613cdce4 Update version number 2019-03-09 20:43:32 -05:00
Ben12345rocks 799340ce06 Added config option 2019-03-09 20:42:21 -05:00
Ben12345rocks ea1a033f2e Changes 2019-03-08 17:09:39 -05:00
Ben12345rocks dabdd8ae8f Add basic preloading 2019-03-07 20:35:45 -05:00
Ben12345rocks 3e2b7eede9 Config update 2019-03-07 18:52:12 -05:00
Ben12345rocks f941deed79 remove hardcode of vote today, closes #512 2019-03-07 18:40:44 -05:00
Ben12345rocks f601b4a134 Add debug for when user in vanish 2019-02-27 19:04:37 -05:00
Ben12345rocks 26630725bd Prevent loading plugin on 1.11 or lower 2019-02-26 18:55:13 -05:00
Ben12345rocks 7faa90ce43 Merge branch 'master' of https://github.com/Ben12345rocks/VotingPlugin 2019-02-23 19:25:15 -05:00
Ben12345rocks 4c99b6b06e Remove VotingPlugin.Player from /av givepoints 2019-02-18 17:26:25 -05:00
Ben 2f2d8278a4 Merge pull request #506 from kakd/patch-1
Minor spelling fixes in commens
2019-02-18 16:58:06 -05:00
kakd e8be2974f9 Minor spelling fixes in commens 2019-02-18 16:52:21 -05:00
Ben12345rocks 4930feff94 Add softdepend 2019-02-17 12:17:56 -05:00
Ben12345rocks 132d871039 Update version number 2019-02-16 18:51:38 -05:00
Ben12345rocks aea6954dbb Bug fix 2019-02-16 18:47:40 -05:00
Ben12345rocks 1ee8819e4c Add ability to transfer vote points 2019-02-16 08:12:45 -05:00
Ben12345rocks 41e3b7fbf6 Bug fix 2019-02-12 16:39:46 -05:00
Ben12345rocks 4218d240bc Bug fix 2019-02-11 17:09:17 -05:00
Ben12345rocks 683d6fcc42 Test commit 2019-02-11 17:07:12 -05:00
Ben12345rocks c9f6ab2fa6 Add event for when points received 2019-02-09 20:33:42 -05:00
Ben12345rocks c99d3baa3c Bug fix 2019-02-09 10:31:59 -05:00
Ben12345rocks d0ade2feff Add MVdW placeholders 2019-02-08 20:32:51 -05:00
Ben12345rocks dcebe5a701 Add authme support 2019-02-08 20:16:21 -05:00
Ben12345rocks d33791fb28 Update version number 2019-02-03 12:13:26 -05:00
Ben12345rocks 8512b3ab4f Bug fix 2019-02-01 20:12:06 -05:00
Ben12345rocks 4395d8cc89 Update version number 2019-01-19 19:30:37 -05:00
Ben12345rocks 55f4e6872c Add option to disable skulls for vote top 2019-01-13 12:19:09 -05:00
Ben12345rocks 6699a9204c Bug fix 2019-01-12 17:40:49 -05:00
Ben12345rocks 14e1a975c9 Improvements 2019-01-09 17:26:27 -05:00
Ben12345rocks 7ab3c4bcf9 Possible bug fix 2019-01-08 18:25:52 -05:00
Ben12345rocks 1866196571 Improvements 2019-01-07 16:47:25 -05:00
Ben12345rocks 301c21ed20 Preload skull for top voter 2019-01-06 14:01:55 -05:00
Ben12345rocks 2d5208a568 Update version number 2018-12-30 18:34:37 -05:00
Ben12345rocks 44a543e64c Bug fix 2018-12-30 18:34:09 -05:00
Ben12345rocks 458c66819a Bug fix 2018-12-30 17:35:27 -05:00
Ben12345rocks dcf4f3f15d Update version number 2018-12-30 15:20:25 -05:00
Ben12345rocks e33ef5420a Added another command 2018-12-30 13:05:55 -05:00
Ben12345rocks 8d1c3a05ce Add new command 2018-12-30 12:27:40 -05:00
Ben12345rocks 9a167a46d8 More command work 2018-12-29 20:54:45 -05:00
Ben12345rocks ffe60808b6 Added sound for inv clicks, command improvements 2018-12-29 20:45:54 -05:00
Ben12345rocks 1affd6c2fa Increase player name length 2018-12-29 19:27:02 -05:00
Ben12345rocks 17225dca5b Bug fixes 2018-12-22 19:54:20 -05:00
Ben12345rocks fc9f55ead8 Bug fix 2018-12-17 16:47:19 -05:00
Ben12345rocks eec877623e Add a class to make voting plugin hooks a lot easier 2018-12-16 19:15:48 -05:00
Ben12345rocks a06b0573c5 Made day vote streak update faster 2018-12-16 19:09:03 -05:00
Ben12345rocks dfcfee302f Bug fix 2018-12-16 12:39:21 -05:00
Ben12345rocks cb1cc27c60 Update version number 2018-12-15 09:18:56 -05:00
Ben12345rocks aed30a94c0 Bug fixes 2018-12-15 09:17:41 -05:00
Ben12345rocks 8e172e2647 Change default value 2018-12-15 09:01:10 -05:00
Ben12345rocks ca355e1a01 Add new commands 2018-12-14 20:26:46 -05:00
Ben12345rocks b0e18d5224 Added ability to disable aliases 2018-12-13 20:34:17 -05:00
Ben12345rocks f5fc80ef14 Performance improvement 2018-12-13 19:50:10 -05:00
Ben12345rocks 21f846f0bc Added ability to set percentage for vote streak 2018-12-13 19:43:18 -05:00
Ben12345rocks a6a742b91e Performance improvement 2018-12-13 19:23:32 -05:00
Ben12345rocks 4ca6510910 Test commit 2018-12-12 17:02:50 -05:00
Ben12345rocks e06ea06884 Code cleanup 2018-12-12 16:57:00 -05:00
Ben12345rocks 2c79dff678 Added new option 2018-12-12 16:43:37 -05:00
Ben12345rocks 56c4a094cf Little fix 2018-12-09 17:01:45 -05:00
Ben12345rocks 1898af9fea Little fix 2018-12-09 16:39:46 -05:00
Ben12345rocks 885d2bc019 Improvements 2018-12-09 15:39:54 -05:00
Ben12345rocks 12c604d09c Bug fix 2018-12-08 21:55:49 -05:00
Ben12345rocks 7b48699b39 Another spelling mistake 2018-12-08 19:49:24 -05:00
Ben12345rocks 3b5593882f Fix spelling mistake 2018-12-08 19:46:28 -05:00
Ben12345rocks 8c72154eed Update version number 2018-12-08 19:29:48 -05:00
Ben12345rocks 0dc942ecfd Add option to disable update checks 2018-12-07 17:24:36 -05:00
Ben12345rocks bc4d051590 Fix description 2018-12-06 18:57:10 -05:00
Ben12345rocks 011a0322ea Added new canvote placeholder for votesites 2018-12-06 18:56:30 -05:00
Ben12345rocks ed90db12a4 Add more placeholders 2018-12-05 19:51:29 -05:00
Ben12345rocks 3afea03485 Added ability to convert from superbvote 2018-12-05 19:26:58 -05:00
Ben12345rocks 6da17ee181 Minor fixes 2018-12-05 19:10:49 -05:00
Ben12345rocks e5d1c255c0 Add debug to vote party 2018-12-05 17:42:15 -05:00
Ben12345rocks b43754661c Added vote reward back button 2018-12-04 16:51:55 -05:00
Ben12345rocks 89c419c8df Bug fix 2018-12-03 21:23:47 -05:00
Ben12345rocks bd6b2b1edb Add permission for base /vote 2018-12-03 21:21:08 -05:00
Ben12345rocks b7c73902f2 Bug fix for vote party 2018-12-02 12:57:28 -05:00
Ben12345rocks c0995447de Broadcast before vote party rewards 2018-12-02 12:11:15 -05:00
Ben12345rocks d970506c76 Little improvements 2018-11-23 20:37:27 -05:00
Ben12345rocks 74fb06302a Little bits of cleanup 2018-11-23 20:28:03 -05:00
Ben12345rocks 1cfed8aa98 Bug fix 2018-11-22 18:31:59 -05:00
Ben12345rocks 9f563c37e5 Bug fix 2018-11-22 18:23:15 -05:00
Ben12345rocks d311588984 Update version number 2018-11-22 18:18:27 -05:00
Ben12345rocks 8c5324f602 Fully fix tab complete 2018-11-22 17:40:14 -05:00
Ben12345rocks 17832a0bf7 Bug fix for now 2018-11-21 16:55:04 -05:00
Ben12345rocks 3c415c63c9 Bug fix 2018-11-19 16:55:59 -05:00
Ben12345rocks 6ab27775d2 Bug fix 2018-11-19 16:39:56 -05:00
Ben12345rocks e04bf8210f Minor change 2018-11-18 14:06:19 -05:00
Ben12345rocks 7b4879ddf1 Bug fix 2018-11-18 13:57:22 -05:00
Ben12345rocks 081ac7bb3c Fix misspelling in config 2018-11-18 13:38:48 -05:00
Ben12345rocks d9894c6b74 Add description for placeholders 2018-11-18 13:35:30 -05:00
Ben12345rocks f13f56c830 Add ability to set description for placeholders 2018-11-18 13:26:21 -05:00
Ben12345rocks b6a67f2aeb Update version number 2018-11-18 12:56:04 -05:00
Ben12345rocks a5b416b210 Bug fix 2018-11-14 16:50:37 -05:00
Ben12345rocks caa4a7a714 Change help message 2018-11-13 20:17:27 -05:00
Ben12345rocks 72aa819361 Add command to force vote party 2018-11-13 20:16:26 -05:00
Ben12345rocks cf52db0c7d Bug fix 2018-11-13 20:13:43 -05:00
Ben12345rocks 5021c4bf67 Remove option 2018-11-13 19:45:16 -05:00
Ben12345rocks 9dd8e757d4 Fix typo 2018-11-13 19:26:00 -05:00
Ben12345rocks da7cdb74d4 Bug fix 2018-11-13 16:55:05 -05:00
Ben12345rocks 18c6ee6614 Bug fixes 2018-11-13 16:53:08 -05:00
Ben12345rocks cafe2b1de7 Slight case change on command 2018-11-05 19:29:56 -05:00
Ben12345rocks 74c94746c1 Check milestones on amount edit 2018-11-04 12:27:31 -05:00
Ben12345rocks 61130a1b2b Slight changes 2018-11-03 20:48:39 -04:00
Ben12345rocks 7dafa5c8eb Bug fix 2018-11-03 20:45:13 -04:00
Ben12345rocks c89edc47c3 Add more placeholders 2018-11-03 20:30:05 -04:00
Ben12345rocks 0b89df6262 Improve /av servicesites 2018-11-03 20:20:36 -04:00
Ben12345rocks c2218b2c67 Added command to set milestone count 2018-11-02 16:50:06 -04:00
Ben12345rocks 1950cfdd2d Little bug fixes 2018-11-01 19:23:08 -04:00
Ben12345rocks 71af70a026 Add new commands 2018-10-30 20:40:03 -04:00
Ben12345rocks b269c29f7c Add option to wait until votedelay is over to accept vote, closes #437 2018-10-29 19:28:31 -04:00
Ben12345rocks c9e8ade60f Update version number 2018-10-28 13:12:44 -04:00
Ben12345rocks 2364fd7ac6 Simple cleanup 2018-10-27 21:59:57 -04:00
Ben12345rocks 7135ed0f95 Code cleanup 2018-10-27 21:33:25 -04:00
Ben12345rocks b5fbaaaf92 More config api changes 2018-10-27 21:30:25 -04:00
Ben12345rocks 94c025886a Move more config options to newer api 2018-10-27 20:15:58 -04:00
Ben12345rocks 0956466edb Little bit of cleanup 2018-10-26 21:03:20 -04:00
Ben12345rocks b2b23ab622 Add option to only update with players online 2018-10-26 17:09:35 -04:00
Ben12345rocks 0e6529efbe Bug fix 2018-10-25 17:24:39 -04:00
Ben12345rocks f7ce51f63a Clear cache for voteshop 2018-10-25 17:19:48 -04:00
Ben12345rocks 68334ef1a2 Config improvements 2018-10-24 20:03:19 -04:00
Ben12345rocks 404c1eeb4d Added clearcacheonjoin option 2018-10-23 21:00:16 -04:00
Ben12345rocks 347c1d975d Update to 1.13.2 2018-10-23 20:55:17 -04:00
Ben12345rocks 3b022fc841 Bug fixes 2018-10-23 20:48:47 -04:00
Ben12345rocks 88afb70fad Add new option to always update 2018-10-23 16:54:01 -04:00
Ben12345rocks 62e21d9f93 Use lombok 2018-10-21 15:18:36 -04:00
Ben12345rocks 20289a5d7b Slight change 2018-10-21 13:52:24 -04:00
Ben12345rocks 02b0103fbd Add option to process rewards 2018-10-21 13:25:36 -04:00
Ben12345rocks a514ad6cac Javadoc fix 2018-10-20 17:21:08 -04:00
Ben12345rocks 894f1147fd Update version number 2018-10-20 17:17:03 -04:00
Ben12345rocks 6a881b7c5f Cleanup 2018-10-18 19:54:20 -04:00
Ben12345rocks b3eaac0fbb Change how placeholders work in vote shop 2018-10-17 20:05:51 -04:00
Ben12345rocks 4444b53106 Bug fix 2018-10-17 19:57:31 -04:00
Ben12345rocks ec4a28a63e Add vote shop limit system 2018-10-16 17:43:19 -04:00
Ben12345rocks f3722a32f5 Undo little change 2018-10-15 20:29:00 -04:00
Ben12345rocks b3cf416fc4 Minor change 2018-10-15 20:17:02 -04:00
Ben12345rocks 66c2f3a5a6 Minor fixes, changes to sign loading 2018-10-15 20:04:03 -04:00
Ben12345rocks 50609d6729 Little bit of cleanup 2018-10-14 19:28:13 -04:00
Ben12345rocks 0635e7370e Minor fixes 2018-10-14 13:59:10 -04:00
Ben12345rocks f94951cffa Send a player a message if service site might be invalid of fake votes 2018-10-14 13:44:39 -04:00
Ben 5ebdcca3e6 Update .project 2018-10-14 13:30:58 -04:00
Ben f00b7df49b Delete Build to server.launch 2018-10-14 13:30:27 -04:00
Ben12345rocks e0a6c14825 Copy to test server on build 2018-10-14 13:28:58 -04:00
Ben12345rocks a3bcc4a391 Change how votes are processed 2018-10-13 08:37:04 -04:00
Ben12345rocks 7af7034149 Update to advancedcore changes 2018-10-08 17:52:43 -04:00
Ben12345rocks 3cb18946ed lots of code improvements 2018-10-07 14:27:32 -04:00
Ben12345rocks ac604ee538 Change how fast signs update 2018-10-07 13:50:26 -04:00
Ben12345rocks aac3c129cc Change api for special rewards 2018-10-07 13:47:33 -04:00
Ben12345rocks 28695094ca Undo change for now, so no need to update expansion 2018-10-07 13:36:45 -04:00
Ben12345rocks ac583d58bc Slight changes 2018-10-06 09:05:42 -04:00
Ben12345rocks 52de25fad3 Relocate classes 2018-10-03 19:47:50 -04:00
Ben12345rocks 72bf623007 More improvements to placeholders, command to see values of a player 2018-10-03 19:44:02 -04:00
Ben12345rocks c6e61ea5a5 Javadoc fix 2018-09-30 13:29:43 -04:00
Ben12345rocks b400476758 Improvements, update version number 2018-09-30 13:22:11 -04:00
Ben12345rocks 9ff0fc8356 Switch to new methods 2018-09-29 09:16:14 -04:00
Ben12345rocks f7b142e8c6 A lot of api changes/improvements 2018-09-27 21:12:50 -04:00
Ben12345rocks 4d80915811 Improvements 2018-09-27 20:55:23 -04:00
Ben12345rocks f1edc73eca New placeholder api, command to see placeholders, not fully tested 2018-09-26 21:04:55 -04:00
Ben12345rocks 197beb1792 Remove need for slot numbers in vote gui 2018-09-26 20:24:54 -04:00
Ben12345rocks 3aed208345 Remove need for slot number in vote shop, other minor changes 2018-09-26 20:18:32 -04:00
Ben12345rocks 27e500fbf0 Lots of changes, added test command 2018-09-19 20:20:46 -04:00
Ben12345rocks a0f6016dcd Bug fix 2018-09-15 20:06:47 -04:00
Ben12345rocks f37abe15c7 Add service site placeholder to broadcasts 2018-09-11 16:46:37 -04:00
Ben12345rocks 8f66733fe7 Update version number 2018-08-26 13:00:45 -04:00
Ben12345rocks 1bafb69f84 Update to 1.13.1, bug fix for vote party 2018-08-26 12:54:30 -04:00
Ben12345rocks ed5ced8b31 Add ability to disable /vote reward 2018-08-25 08:17:40 -04:00
Ben12345rocks 468747847c Minor changes 2018-08-23 20:56:03 -04:00
Ben12345rocks d28ccc85ac Updates 2018-08-23 20:53:13 -04:00
Ben12345rocks 9b5d6333d1 Remove unneeded duplicate name 2018-08-21 17:22:28 -04:00
Ben12345rocks 99307f15c7 Add warning about running versions older than 1.13 2018-08-20 20:06:23 -04:00
Ben12345rocks 8e9db014d1 Bug fix 2018-08-20 19:40:58 -04:00
Ben12345rocks 5e88782475 Bug fix 2018-08-20 19:40:17 -04:00
Ben12345rocks ba50789744 Remove unneeded debug 2018-08-20 19:30:24 -04:00
Ben12345rocks f06e2d8045 Update to redesigned reward system 2018-08-18 21:03:19 -04:00
Ben12345rocks 58e7143a0a Bug fix 2018-08-13 19:16:11 -04:00
Ben12345rocks 0ee3706190 Update version number to 5.14.2 2018-08-11 11:29:31 -04:00
Ben12345rocks 9f7fc3dafd Bug fix 2018-08-11 11:29:03 -04:00
Ben12345rocks d8ce4a9578 Minor config addition 2018-08-11 11:03:45 -04:00
Ben12345rocks 574e8d4a54 Update version number to 5.14.1 2018-08-11 10:59:09 -04:00
Ben12345rocks 19a7a6a733 Change /vote last to show time since vote 2018-08-11 10:43:43 -04:00
Ben12345rocks 1e131e57c3 Minor config change 2018-08-05 12:28:35 -04:00
Ben12345rocks 57795bdb23 Update version number 2018-07-25 19:17:46 -04:00
Ben12345rocks 52bbb76aad Change version to beta 2018-07-22 14:55:01 -04:00
Ben12345rocks 1257ac4600 Update to 1.13 2018-07-22 13:56:34 -04:00
Ben12345rocks 64ffc38405 Convert many users at a time 2018-07-22 13:36:20 -04:00
Ben12345rocks f8009b05bc Bug fixes 2018-07-22 13:28:14 -04:00
Ben12345rocks 114f217046 Bug fixes 2018-07-21 21:44:56 -04:00
Ben12345rocks 2de309cccc Bug fix 2018-07-21 18:38:52 -04:00
Ben12345rocks 7f827857bc Improvements 2018-07-21 17:13:02 -04:00
Ben12345rocks 75e244f678 Quick change 2018-07-18 17:02:58 -04:00
Ben12345rocks a346f28df1 Bug fix 2018-07-18 17:00:56 -04:00
134 changed files with 19426 additions and 11252 deletions

No files matched your search

+30
View File
@@ -0,0 +1,30 @@
---
name: Bug report
about: Bug report for VotingPlugin
title: ''
labels: Possible Bug
assignees: ''
---
**Versions**
Plugin version and spigot version.
**Describe the bug**
A clear and concise description of what the bug is.
**To Reproduce**
Steps to reproduce the behavior:
1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error
**Expected behavior**
A clear and concise description of what you expected to happen.
**Screenshots/Configs**
If applicable, add screenshots to help explain your problem and/or configs relating to the issue.
**Additional context**
Add any other context about the problem here.
+20
View File
@@ -0,0 +1,20 @@
---
name: Feature request
about: Suggest an idea
title: ''
labels: Possible Feature
assignees: ''
---
**Is your feature request related to a problem? Please describe.**
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
**Describe the solution you'd like**
A clear and concise description of what you want to happen.
**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features you've considered.
**Additional context**
Add any other context or screenshots about the feature request here.
@@ -0,0 +1,17 @@
---
name: Question/Concerns
about: Ask about a question or a concern about the plugin
title: ''
labels: Question/Concern
assignees: ''
---
**Versions**
Plugin version and spigot version
**Relevant information**
Configs that relate to the issue in a pastebin.
**Context**
Context about the question/concern
+17
View File
@@ -0,0 +1,17 @@
# Number of days of inactivity before an issue becomes stale
daysUntilStale: 20
# Number of days of inactivity before a stale issue is closed
daysUntilClose: 5
# Issues with these labels will never be considered stale
exemptLabels:
- Priority
- nonstale
# Label to use when marking an issue as stale
staleLabel: stale
# Comment to post when marking an issue as stale. Set to `false` to disable
markComment: >
This issue has been automatically marked as stale because it has not had
recent activity. It will be closed if no further activity occurs. Thank you
for your contributions.
# Comment to post when closing a stale issue. Set to `false` to disable
closeComment: false
+6 -2
View File
@@ -2,9 +2,13 @@
Plugin on SpigotMC
https://www.spigotmc.org/resources/votingplugin.15358/
![img](http://badge.henrya.org/spigot/downloads?id=15358&color=green)
![img2](http://badge.henrya.org/spigot/version?id=15358&color=red)
## License
### Creative Commons Arttribution 3.0 Unported
https://github.com/Ben12345rocks/VotingPlugin/blob/master/VotingPlugin/LICENSE.txt
https://github.com/Ben12345rocks/VotingPlugin/blob/master/VotingPlugin/Resources/LICENSE.txt
### Maven:
@@ -14,7 +18,7 @@ https://github.com/Ben12345rocks/VotingPlugin/blob/master/VotingPlugin/LICENSE.t
</repository>
<dependency>
<groupId>com.github.Ben12345rocks</groupId>
<groupId>com.github.BenCodez</groupId>
<artifactId>VotingPlugin</artifactId>
<version>LATEST</version>
<scope>provided</scope>
+10
View File
@@ -15,6 +15,16 @@
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.eclipse.wst.validation.validationbuilder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.eclipse.m2e.core.maven2Builder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.eclipse.m2e.core.maven2Nature</nature>
@@ -0,0 +1,4 @@
eclipse.preferences.version=1
encoding/<project>=Cp1252
encoding/Resources=Cp1252
encoding/src=Cp1252
@@ -1,13 +1,4 @@
eclipse.preferences.version=1
org.eclipse.jdt.core.compiler.annotation.inheritNullAnnotations=disabled
org.eclipse.jdt.core.compiler.annotation.missingNonNullByDefaultAnnotation=ignore
org.eclipse.jdt.core.compiler.annotation.nonnull=org.eclipse.jdt.annotation.NonNull
org.eclipse.jdt.core.compiler.annotation.nonnull.secondary=
org.eclipse.jdt.core.compiler.annotation.nonnullbydefault=org.eclipse.jdt.annotation.NonNullByDefault
org.eclipse.jdt.core.compiler.annotation.nonnullbydefault.secondary=
org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable
org.eclipse.jdt.core.compiler.annotation.nullable.secondary=
org.eclipse.jdt.core.compiler.annotation.nullanalysis=disabled
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate
org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
@@ -17,40 +8,15 @@ org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.doc.comment.support=disabled
org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
org.eclipse.jdt.core.compiler.problem.autoboxing=ignore
org.eclipse.jdt.core.compiler.problem.comparingIdentical=warning
org.eclipse.jdt.core.compiler.problem.deadCode=warning
org.eclipse.jdt.core.compiler.problem.deprecation=warning
org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
org.eclipse.jdt.core.compiler.problem.discouragedReference=warning
org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore
org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=ignore
org.eclipse.jdt.core.compiler.problem.fallthroughCase=ignore
org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled
org.eclipse.jdt.core.compiler.problem.fieldHiding=ignore
org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts=disabled
org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=warning
org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
org.eclipse.jdt.core.compiler.problem.invalidJavadoc=warning
org.eclipse.jdt.core.compiler.problem.invalidJavadocTags=enabled
org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef=disabled
org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef=disabled
org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility=public
org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore
org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
org.eclipse.jdt.core.compiler.problem.missingDefaultCase=ignore
org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore
org.eclipse.jdt.core.compiler.problem.missingEnumCaseDespiteDefault=disabled
org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod=ignore
org.eclipse.jdt.core.compiler.problem.missingJavadocComments=warning
org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=disabled
org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=public
@@ -59,65 +25,6 @@ org.eclipse.jdt.core.compiler.problem.missingJavadocTags=warning
org.eclipse.jdt.core.compiler.problem.missingJavadocTagsMethodTypeParameters=disabled
org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=disabled
org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=public
org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore
org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotationForInterfaceMethodImplementation=enabled
org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning
org.eclipse.jdt.core.compiler.problem.missingSynchronizedOnInheritedMethod=ignore
org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore
org.eclipse.jdt.core.compiler.problem.nonnullParameterAnnotationDropped=warning
org.eclipse.jdt.core.compiler.problem.nonnullTypeVariableFromLegacyInvocation=warning
org.eclipse.jdt.core.compiler.problem.nullAnnotationInferenceConflict=error
org.eclipse.jdt.core.compiler.problem.nullReference=warning
org.eclipse.jdt.core.compiler.problem.nullSpecViolation=error
org.eclipse.jdt.core.compiler.problem.nullUncheckedConversion=warning
org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
org.eclipse.jdt.core.compiler.problem.parameterAssignment=ignore
org.eclipse.jdt.core.compiler.problem.pessimisticNullAnalysisForFreeTypeVariables=warning
org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=ignore
org.eclipse.jdt.core.compiler.problem.potentialNullReference=warning
org.eclipse.jdt.core.compiler.problem.potentiallyUnclosedCloseable=ignore
org.eclipse.jdt.core.compiler.problem.rawTypeReference=warning
org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning
org.eclipse.jdt.core.compiler.problem.redundantNullCheck=ignore
org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=ignore
org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=ignore
org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore
org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=ignore
org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=info
org.eclipse.jdt.core.compiler.problem.suppressOptionalErrors=disabled
org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled
org.eclipse.jdt.core.compiler.problem.syntacticNullAnalysisForFields=disabled
org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning
org.eclipse.jdt.core.compiler.problem.unavoidableGenericTypeProblems=enabled
org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning
org.eclipse.jdt.core.compiler.problem.unclosedCloseable=warning
org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore
org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning
org.eclipse.jdt.core.compiler.problem.unlikelyCollectionMethodArgumentType=warning
org.eclipse.jdt.core.compiler.problem.unlikelyCollectionMethodArgumentTypeStrict=disabled
org.eclipse.jdt.core.compiler.problem.unlikelyEqualsArgumentType=info
org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore
org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=ignore
org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore
org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable=enabled
org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference=enabled
org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
org.eclipse.jdt.core.compiler.problem.unusedExceptionParameter=ignore
org.eclipse.jdt.core.compiler.problem.unusedImport=warning
org.eclipse.jdt.core.compiler.problem.unusedLabel=warning
org.eclipse.jdt.core.compiler.problem.unusedLocal=warning
org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation=ignore
org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference=enabled
org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=warning
org.eclipse.jdt.core.compiler.problem.unusedTypeParameter=ignore
org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=ignore
org.eclipse.jdt.core.compiler.release=disabled
org.eclipse.jdt.core.compiler.source=1.8
@@ -1,4 +1,4 @@
activeProfiles=
activeProfiles=dev
eclipse.preferences.version=1
resolveWorkspaceProjects=true
version=1
@@ -0,0 +1,8 @@
DELEGATES_PREFERENCE=delegateValidatorList
USER_BUILD_PREFERENCE=enabledBuildValidatorList
USER_MANUAL_PREFERENCE=enabledManualValidatorList
USER_PREFERENCE=overrideGlobalPreferencesfalse
eclipse.preferences.version=1
override=false
suspend=false
vf.version=3
Binary file not shown.
Binary file not shown.
Binary file not shown.
+60
View File
@@ -0,0 +1,60 @@
# --------------------------
# Bungee Setup
# Only if using votingplugin bungee to send votes
# REQUIRES RESTART FOR CHANGES TO TAKE EFFECT
# --------------------------
# Plugin using bungee, requires plugin on bungee server
UseBungeecord: false
# What type of bungee setup
# Requires restart and set on all servers
# https://github.com/Ben12345rocks/VotingPlugin/wiki/Bungeecoord-Setups
# Available:
# SOCKETS
# PLUGINMESSAGING
# MYSQL
BungeeMethod: PLUGINMESSAGING
# Enables more debug messages for communication between servers
# Use /votingpluginbungee status for testing communication
BungeeDebug: false
# Get the plugin to broadcast to all servers
# If false you need to enable
# Only use for global rewards (one per network), otherwise you will get double broadcasts
BungeeBroadcast: false
# For pluginmessaging method only
# Whether to broadcast on cached votes
BungeeBroadcastAlways: false
# If true, offline rewards will be stored per server, rather than global
# This shouldn't need to be set unless you get alot of cross server rewards issues
# You can also specify the server within the rewards
# Requires server name below to be correct
PerServerRewards: false
# If true, plugin will trigger VotifierEvent
# Should allow some compability with other plugins
TriggerVotifierEvent: false
# What server this is in bungee (must match)
# Also can be applied to rewards
Server: PleaseSet
# -----------------------------
# For socket setup below only
# -----------------------------
# Bungee communication, add bungee host/port here
# For socket method
BungeeServer:
Host: '127.0.0.1'
Port: 1297
# Bungee communication, add this to bungee server
# For socket method
SpigotServer:
Host: '127.0.0.1'
Port: 1298
+294 -525
View File
@@ -2,14 +2,17 @@
# Main Config
# See wiki for help:
# https://github.com/Ben12345rocks/VotingPlugin/wiki
# Config is sorted in sections
# Use Control + F to search with Notepad++
#
# Valid Options:
# - SQLITE
# - SQLITE
# - FLAT
# - MYSQL
DataStorage: SQLITE
# Information for mysql
# See the end of the config for cache options
MySQL:
Host: ''
# Default port is 3306
@@ -26,22 +29,44 @@ MySQL:
# Table name prefix, for use with mutliple servers
Prefix: ''
#UseSSL: true
#PublicKeyRetrieval: false
# ---------------------------------------------------------
# Mysql cache options
# Clearing cache forces the plugin to pull from database
# Not needed unless you are using multiple servers
# If using a bungee setup most of these options are overriden automatically
# ---------------------------------------------------------
# Clear cache on update, setting to true reduces update speed
# Also may require AlwaysUpdate set to true
ClearCacheOnUpdate: false
# Clear cache on player join always
ClearCacheOnJoin: false
# Clears cache for the player who voted only
# Only effects if using mysql
# Would recommend for some bungee setups
ClearCacheOnVote: false
# Clear cache when player leaves
ClearCacheOnLeave: false
ClearCacheOnVoteShopPurchase: true
# --------------------
# AllowUnJoined options
# May need to set to true for bungee setup
# --------------------
# Let players who never joined before vote
# Recommend: False (Will prevent creating random user data files)
# Recommend: False (Will prevent creating random user data)
AllowUnjoined: false
# If true, plugin will send scoreboards on some commands
SendScoreboards: true
# If true, plugin will automaticly generate votesites
# Disable this if you experience issues with sites being created randomly
AutoCreateVoteSites: true
# Automaticly download the latest version
# Will require a restart to actually update
# Note that updates take 30-40 minutes to load before they can be downloaded
AutoDownload: false
# Use server lookup for when allowunjoined is set to false
# Recommend leaving enabled unless you face issues
AllowUnJoinedCheckServer: true
# ------------------------------------------------
# VoteReminding
@@ -53,12 +78,12 @@ AutoDownload: false
VoteReminding:
# Enable vote reminding
# This will remind player when he can vote on all sites
# Requires VoteDelay's to be setup properly
# Requires VoteDelays to be setup properly
# Use /vote next to see when you can be reminded
# Players require the perm "VotingPlugin.Login.RemindVotes" or "VotingPlugin.Player"
Enabled: true
# Wether or t to remind only once when the player can vote
# Whether or not to remind only once when the player can vote
# Does not apply to login reminds.
RemindOnlyOnce: true
@@ -85,37 +110,25 @@ VoteReminding:
FadeIn: 10
ShowTime: 50
FadeOut: 10
ActionBar:
Message: '&cRemember to vote'
Delay: 30
# ------------------------------------------------
# Format
# ------------------------------------------------
# Common PlacesHolders:
# Please Note: Not all are usable in all sections
# Special PlaceHolders will be commented where available
# %player% = player name
# %SiteName% = vote site name
#
# Set Message to '' (2 ') to disable message
Commands:
# Wether or not the following commands will open GUIs rather than display text
UseGUI:
Today: true
TopVoter: true
Last: true
Next: true
Total: true
Vote: true
Best: true
Streak: true
# If true, you can right click a votesite from /vote (gui version) and open the vote reward gui for that site
# Can be used to display rewards for that site
VoteRewardFromVoteURL: false
Format:
# CommandHandler help message
HelpLine: '&3&l%Command% - &3%HelpMessage%'
# Mainly used in admin help page, see below for /vote help
HelpLine: '&6%Command% - &6%HelpMessage%'
# Broadcast vote message
# Set to an empty message to disable
@@ -124,13 +137,20 @@ Format:
# Broadcast only when player is online
BroadcastWhenOnline: false
# Broadcast every x number of minutes with number of players that voted
AlternateBroadcast:
Enabled: false
Broadcast: '&6[&4Broadcast&6] &2%numberofplayers% voted in the last half hour! /vote'
# Delay in minutes
Delay: 30
Commands:
# Format for /vote
# %num% = the number of the site, for a numbered list
# %url% = site URL
Vote:
Text:
- '&4&lVote for our server!'
- '&3&lVote for our server!'
# If you want to want to use the feature below where the plugin will
# automaticly list the sites then set the message in the text above
@@ -139,7 +159,10 @@ Format:
# make sure to set VoteURL in your VoteSites
# Requires above to be true
# Text will be sent before this
Sites: '&4%num%: &c&l%SiteName% - &c%url%'
Sites: '&3%num%: &6&l%SiteName% &6- %url%'
# If true, links will always be forced as urls
ForceLinks: true
# Format for /vote next
Next:
@@ -169,7 +192,12 @@ Format:
Title: '&3&l%player% Last Vote Times:'
# Lines for each vote site
# %time% = time, using timeformat below
Line: '&3%SiteName%: &6%time%'
# %timesince% = time since vote
Line: '&3%SiteName%: &6%timeSince%'
# Spelling of TimeType can be changed under Format.Commands.TimeFormats
TimeFormat: '%amount% %TimeType%'
LastVoted: '%times% ago'
NeverVoted: 'Never voted'
# Format for /vote total
Total:
@@ -200,9 +228,9 @@ Format:
# Format for /vote help
Help:
# Title of /vote help
Title: '&3&lVoting Player Help'
Title: '&6&lVoting Player Help'
# Format for help message in /v help
Line: '&3&l%Command% - &3%HelpMessage%'
Line: '&6%Command% - &6%HelpMessage%'
# Require permission to see command in /v help or /av help
RequirePermission: true
@@ -224,6 +252,12 @@ Format:
- '&3Highest Week Streak: &3&l%BestWeeklyStreak%'
- '&3Highest Month Streak: &3&l%BestMonthlyStreak%'
Today:
Title:
- "&cToday's Votes %page%/%maxpage%"
- '&cPlayerName : VoteSite : Time'
Line: '&6%player% : %VoteSite% : %Time%'
# PlaceHolders:
# %VotesRequired% = VotesRequired
# %NeededVotes% = Number of votes needed to reach VotesRequired
@@ -234,7 +268,7 @@ Format:
# %Points% = player points
Points: '&a%Player% currently has &a&l%Points%&a Points!'
ToggleBroadcast:
ToggleBroadcasts:
Enabled: '&cYou will now see vote broadcasts'
Disabled: '&cYou will no longer see vote broadcasts'
@@ -246,6 +280,19 @@ Format:
# See https://docs.oracle.com/javase/7/docs/api/java/text/SimpleDateFormat.html
TimeFormat: 'EEE, d MMM yyyy HH:mm'
# Reward time format for %date% placeholder (Time of giving reward)
RewardTimeFormat: 'EEE, d MMM yyyy HH:mm'
TimeFormats:
Day: 'Day'
Days: 'Days'
Hour: 'Hour'
Hours: 'Hours'
Minute: 'Minute'
Minutes: 'Minutes'
Second: 'Second'
Seconds: 'Seconds'
# Format for signs
# SiteName may be all, depending on sign
# %position% = position of player, set by sign
@@ -272,11 +319,18 @@ Format:
# User not exist message, from commands such as /vote next (player)
UserNotExist: '&cUser does not exist: %player%'
# Text for page buttons in inventories
PrevPage: '&aPrevious Page'
NextPage: '&aNext Page'
# Prev/Next page tems in GUIs
PrevItem:
Material: 'BLACK_STAINED_GLASS_PANE'
Amount: 1
Name: '&aPrevious Page'
NextItem:
Material: 'BLACK_STAINED_GLASS_PANE'
Amount: 1
Name: '&aNext Page'
InvFull: '&cInventory full, dropping items on ground'
InvFull: '&cInventory full'
# Display text
# Used in /vote top (GUI)
@@ -286,415 +340,19 @@ Format:
Monthly: 'Monthly'
AllTime: 'AllTime'
# ------------------------------------------------
# GUI Options
# ------------------------------------------------
# Configure GUI's here
# Note: Slots start at 0 instead of 1, max slot is 53 (don't go over) (E.g: last slot in first row of inventory is 8)
# Item Material's can be found here: https://hub.spigotmc.org/javadocs/spigot/org/bukkit/Material.html
GUI:
# GUI for /vote gui, /vgui, votegui
VoteGUI:
# Items will be orders as it is below
URL:
# Standard item format, lore is automaticly applied
Item:
Material: 'BOW'
Data: 0
Amount: 1
Name: '&4URL'
# You can set skulls of the player using the following
# Remove the # to enable
#Skull: '%Player%'
Slot: 0
Next:
Item:
Material: 'COMPASS'
Data: 0
Amount: 1
Name: '&4Next'
Slot: 1
Last:
Item:
Material: 'WATCH'
Data: 0
Amount: 1
Name: '&4Last'
Slot: 2
Total:
Item:
Material: 'CHEST'
Data: 0
Amount: 1
Name: '&4Total'
Slot: 3
Top:
Item:
Material: 'SIGN'
Data: 0
Amount: 1
Name: '&4Top'
Slot: 4
Today:
Item:
Material: 'BOOK'
Data: 0
Amount: 1
Name: '&4Today'
Slot: 5
Shop:
Item:
Material: 'DIAMOND'
Data: 0
Amount: 1
Name: '&4Vote Shop'
Lore:
- '&aYou currently have %points% points'
Slot: 6
# GUI for /vote url
# And /vote if enabled in Config.yml
VoteURL:
# GUI Name
Name: '&cVoteURL'
BackButton: true
SiteName: '&c%Name%'
SeeURL: '&cClick to see URL'
NextVote: '&cCan Vote In: %Info%'
ViewAllUrlsButtonEnabled: true
AllUrlsButton:
AlreadyVotedItem:
Material: 'REDSTONE_BLOCK'
Data: 0
Amount: 1
Name: '&4All Voting Sites'
Lore:
- '&cClick Me'
CanVoteItem:
Material: 'EMERALD_BLOCK'
Data: 0
Amount: 1
Name: '&4All Voting Sites'
Lore:
- '&cClick Me'
AlreadyVotedItem:
Material: 'REDSTONE_BLOCK'
Data: 0
Amount: 1
CanVoteItem:
Material: 'EMERALD_BLOCK'
Data: 0
Amount: 1
URLText: '%VoteUrl%'
# Customize /vote reward
# Show players what you get when you vote on each site
VoteReward:
# Name of votesite
ExampleVoteSite:
# items in /vote reward sitename
Items:
# Item
# This is not the item display name
# Do not have 2 of the same items
Diamond:
# Item ID
Material: 'DIAMOND'
# Item Data (Eg 1:4, data is 4)
Data: 0
# Amount of items
# Should be greater than 0
Amount: 1
# Item name
# Remove this line for no name
Name: '&4Example'
# Lore
# Remove this line for no lore
Lore:
- '&4Line 1'
Slot: 0
VoteLast:
Name: 'VoteLast: %player%'
BackButton: true
VoteNext:
Name: 'VoteNext: %player%'
BackButton: true
VoteToday:
Name: 'VoteToday'
BackButton: true
VoteTop:
Name: 'VoteTop %topvoter%'
BackButton: false
Item:
Name: '&3&l%position%: &3%player%'
Lore: '&3&lVotes: &3%votes%'
SwitchItem:
Name: 'Switch TopVoter'
Lore: 'Currently: %Top%'
Material: 'SIGN'
Amount: 1
# 8 Slots over from the bottom left
Slot: 7
# Number of topvoters to display on page +9
# 9 Slots on the botton are used for page buttons
Size: 27
VoteTotal:
Name: 'VoteTotal: %player%'
BackButton: true
DayTotal:
Item:
Material: 'WATCH'
Name: '&cDaily Total'
Lore: '&c&lTotal: &c%Total%'
Amount: 1
WeekTotal:
Item:
Material: 'WATCH'
Name: '&cWeekly Total'
Lore: '&c&lTotal: &c%Total%'
Amount: 1
MonthTotal:
Item:
Material: 'WATCH'
Name: '&cMonthly Total'
Lore: '&c&lTotal: &c%Total%'
Amount: 1
AllTimeTotal:
Item:
Material: 'WATCH'
Name: '&cAllTime Total'
Lore: '&c&lTotal: &c%Total%'
Amount: 1
VoteBest:
Name: 'VoteBest: %player%'
DayBest:
Item:
Material: 'WATCH'
Name: '&cDaily Best'
Lore: '&c&lBest: &c%Best%'
Amount: 1
WeekBest:
Item:
Material: 'WATCH'
Name: '&cWeekly Best'
Lore: '&c&lBest: &c%Best%'
Amount: 1
MonthBest:
Item:
Material: 'WATCH'
Name: '&cMonthly Best'
Lore: '&c&lBest: &c%Best%'
Amount: 1
VoteStreak:
Name: 'VoteStreak: %player%'
BackButton: false
CurrentDayStreak:
Item:
Material: 'WATCH'
Name: '&cCurrent Daily Streak'
Lore: '&c&lStreak: &c%Streak%'
Amount: 1
CurrentWeekStreak:
Item:
Material: 'WATCH'
Name: '&cCurrent Weekly Streak'
Lore: '&c&lStreak: &c%Streak%'
Amount: 1
CurrentMonthStreak:
Item:
Material: 'WATCH'
Name: '&cCurrent Monthly Streak'
Lore: '&c&lStreak: &c%Streak%'
Amount: 1
HighestDayStreak:
Item:
Material: 'WATCH'
Name: '&cHighest Daily Streak'
Lore: '&c&lStreak: &c%Streak%'
Amount: 1
HighestWeekStreak:
Item:
Material: 'WATCH'
Name: '&cHighest Weekly Streak'
Lore: '&c&lStreak: &c%Streak%'
Amount: 1
HighestMonthStreak:
Item:
Material: 'WATCH'
Name: '&cHighest Monthly Streak'
Lore: '&c&lStreak: &c%Streak%'
Amount: 1
VoteURLSite:
Name: 'VoteSite: %site%'
VoteGUIName: '&cVoteGUI: &c&l%player%'
VoteRewardName: 'VoteReward'
VoteShopName: 'VoteShop'
BackButton:
Material: 'PAPER'
Data: 0
Amount: 1
Name: '&8Back to VoteGUI'
VoteShopBackButton: true
VoteShopEnabled: true
Shop:
# Identifier
# Used in placeholders for formats
Diamond:
# Item
Material: 'DIAMOND'
Data: 0
Amount: 1
Name: '&4Buy A Diamond'
# You can set skulls of the player using the following
# Remove the # to enable
#Skull: '%Player%'
Lore:
- '&c&lCost: &c3 Voting Points'
# Number of voting points this cost
Cost: 3
# Permission required, leave blank for no permission
Permission: ''
# Rewards to run if player buys succesfully
Rewards:
Items:
Diamond:
Material: 'DIAMOND'
Amount: 1
# Slot
Slot: 0
# ------------------------------------------------
# Extra Rewards
# ------------------------------------------------
# To disable reward set value to []
# Eg:
# FirstVote: [] (All in one line)
# By default all rewards are disabled
# First vote rewards
FirstVote:
Messages:
Player: '&aYou voted for your first time!'
Money: 100
# All vote rewards
# Reward for voting on all sites in one day
AllSites:
Messages:
Player: '&aYou voted on all sites in 1 day!'
Cumulative:
# Number of votes required
# Allows multiple cumulative rewards
# Number be be around ' (E.g. '1')
# Can have multiple listed here
'20':
Enabled: false
# Wether or not votes must be made in same day/week
# Useful if you want to require a certain number of voting sites to be voted on
# for a daily/weekly reward instead of all of them
VotesInSameDay: false
VotesInSameWeek: false
Rewards:
Messages:
Player: '&aYou got %cumulative% cumulative votes!'
VoteParty:
# Wether or not vote party is enabled
Enabled: false
# Number of votes required to give rewards
VotesRequired: 20
# Increase the amount of votes required on each vote party reached
#IncreaseVotesRquired: 10
# If true, players who did not vote to reach the votes required will
# recieve the reward
GiveAllPlayers: false
# If true, the vote count will reset each day
ResetEachDay: false
# Reset at the end of the month
ResetMonthly: false
# Count votes from /av vote?
CountFakeVotes: true
# Number of user votes that apply to vote party total the user needs to get rewards
UserVotesRequired: 0
# Broadcast when vote party reached
Broadcast: '&cReached the vote party amount!'
# List of commands to execute, these only execute once.
Commands: []
# Reward files to give
Rewards: []
# Reset milestons at end of the month
ResetMilestonesMonthly: false
MileStones:
# Number of votes required
# Allows multiple milestones
# Number be be around ' (E.g. '1')
# Can have multiple listed here
'20':
Enabled: false
Rewards:
Messages:
Player: '&aYou got %milestone% milestone votes!'
VoteStreak:
# Valid options: Day, Week, Month
Day:
# Number of days in a row
# Each day requires one vote
# Add a - to give a reward for every multiple (e.g. 2-)
'2':
# Enabled or not
Enabled: false
# Rewards to give
Rewards:
Messages:
Player: "&aYou voted for %Streak% %Type%'s in a row!"
Week:
# Number of weeks in a row
# Requires atleast one vote per week
'2':
# Enabled or not
Enabled: false
# Rewards to give
Rewards:
Messages:
Player: "&aYou voted for %Streak% %Type%'s in a row!"
Month:
# Number of months in a row
# Requires atleast 1 vote per month
'2':
# Enabled or not
Enabled: false
# Rewards to give
Rewards:
Messages:
Player: "&aYou voted for %Streak% %Type%'s in a row!"
# ONLY USE THIS FOR TITLES/SOUNDS AND OTHER EFFECTS
# IT WILL ONLY RUN ONE TIME FOR ANY NUMBER OF OFFLINE VOTES
# Any reward files listed here are ran on vote of any site
# It is recommended to add rewards to each site instead of here
# Using forceoffline won't work here
AnySiteRewards: []
# ------------------------------------------------
# Top Voter
# Top voter rewards available in specialrewards.yml
# ------------------------------------------------
# Top voter blacklist
# Hide these names from top voter lists
BlackList:
- 'Notch'
# If true players with the permission 'VotingPlugin.TopVoter.Ignore' will act
# as if there name was added on the the blacklist above
# This also applies for ops
# This also applies for players with op
TopVoterIgnorePermission: false
# /vote top default data displayed
@@ -710,60 +368,45 @@ LoadTopVoter:
Monthly: true
Weekly: false
Daily: false
# Maxium number of players to show on top voter
# Set to -1 for no limit
MaxiumNumberOfTopVotersToLoad: -1
# When top voter awards are given (even if there are none listed) it will store top voters
# Files will created in TopVoters folder.
# Monthly top voters are always saved by default now
StoreTopVoters:
Monthly: true
Weekly: false
Daily: false
EnableMonthlyAwards: true
# Rewards to give
MonthlyAwards:
# Position. 1 is first in top voter, 2 is second, etc...
# Using 1-10 will reward players in first to tenth place with the same reward
1:
Rewards:
Messages:
Player: '&aYou came in first place in %TopVoter%!'
2:
Rewards:
Messages:
Player: '&aYou came in second place in %TopVoter%!'
EnableWeeklyAwards: false
# Rewards to give on weekly top voter
WeeklyAwards:
# Position. 1 is first in top voter, 2 is second, etc...
1:
Rewards:
Messages:
Player: '&aYou came in first place in %TopVoter%!'
2:
Rewards:
Messages:
Player: '&aYou came in second place in %TopVoter%!'
EnableDailyRewards: false
# Rewards to give on daily top voter
DailyAwards:
# Position. 1 is first in top voter, 2 is second, etc...
1:
# Reward files to give
Rewards:
Messages:
Player: '&aYou came in first place in %TopVoter%!'
2:
Rewards:
Messages:
Player: '&aYou came in second place in %TopVoter%!'
# ------------------------------------------------
# Advanced
# Most of these values can be left untouched
# Most of these values can be left untouched for most setups
# ------------------------------------------------
# If true vanished players are treated as if they are offline
TreatVanishAsOffline: false
# If true, cooldown check is disabled
DisableCoolDownCheck: false
# If true, disable PlayerInteractEvent (for clicking signs and skulls)
DisableInteractEvent: false
# Delays login event, delays vote reminding and more
# In ticks
DelayLoginEvent: 0
# If false, votestreaks will be disabled
UseVoteStreaks: true
# If false, storing best totals will be disabled
UseHighestTotals: true
# If true, /vote will open /vote gui by default
UseVoteGUIMainCommand: false
# Number of points to give on vote
# Set to 0 to give no points
PointsOnVote: 1
@@ -772,16 +415,74 @@ PointsOnVote: 1
# Not really recommended
AddTotals: true
# Disable checking on world change
# May improve performance
DisableCheckOnWorldChange: false
# If true, items given for rewards are dropped on the ground
# If false, items will be given when there is space
DropOnFullInv: true
# If true, allsites will have an extra check to prevent duplicate allsites from being given
ExtraAllSitesCheck: false
# Click sound when using gui
# Set to none for no sound
ClickSound:
Sound: 'UI_BUTTON_CLICK'
Volume: 1.0
Pitch: 1.0
# Playernames to not be broadcasted when voting
# case sensitive
VotingBroadcastBlacklist: []
# When enabled, javascript will be parsed on placeholders (from placeholderapi)
# allows more fancy placeholders with math for example
UseJavascriptPlaceholders: false
# Limit monthly votes to number of days of a month multipled by the number of sites
LimitMonthlyVotes: false
# This is an extra safe guard to prevent milestones
# from being executed more than once
# Shoudn't be needed, but enable if you have trouble with milestones
PreventRepeatMilestones: false
# When enabled the command /vote setprimaryaccount (playername)
# will be shown (after restart)
# Primary account will be used instead of the players account to get
# placeholder and other data such as vote reminding
# Mainly to be used for alts and such
UsePrimaryAccountForPlaceholders: false
# If true, permissions will be handled differently
MultiplePermissionsCheck: false
AddCustomCommands: false
# Injects custom command to /vote
# Requires AddCustomCommand: true to be set
CustomCommands:
# identifier, not specific name
command1:
Args:
- token
# Message to send on command
Message: 'token message'
# Permission for this command
Permission: 'votingplugin.commands.vote.token'
# help message
HelpMessage: 'See tokens'
# Forces player to run this command
Commands:
- tokencommand
######################
# Debug
Debug: false
######################
# Extra Debug
# Only needed in extreme cases
ExtraDebug: false
# Debug levels:
# NONE
# INFO
# EXTRA
DebugLevel: NONE
# Debug info ingame
# Players with permission "VotingPlugin.Debug"
@@ -789,49 +490,30 @@ ExtraDebug: false
DebugInGame: false
# Will log debug messages to VotingPlugin/Log/log.txt
# Requires Debug to be on
LogDebugToFile: false
# Options for request api
# Current methods
# ANVIL
# BOOK
# CHAT
# This is mainly used for admin gui's to type in values
RequestAPI:
DefaultMethod: 'Anvil'
DisabledMethods: []
# Only needed for extreme cases
#LogDebugToFile: false
# Wether or not to log every vote to a file
# Whether or not to log every vote to a file
# Use this if you wanna track player votes
# Not recommended though
LogVotesToFile: false
# Only update in the background when needed when set to false
AlwaysUpdate: false
# Update in the background only if players are online
UpdateWithPlayersOnlineOnly: false
# Delay between background updates like signs and more
# Default: 3 Minutes
# Longer times result in longer wait in stuff updating after a vote, like topvoter
DelayBetweenUpdates: 3
# Clear cache on update, setting to true reduces performance
ClearCacheOnUpdate: false
# Clears cache for the player who voted only
# Only effects if using mysql
# Would recommend for some bungee setups
ClearCacheOnVote: false
# Set to true to disable no service site message on voting
# You should never have to touch this if everything is setup properly
# Will also disable a few other warnings about vote sites
DisableNoServiceSiteMessage: false
# Used in special cases
# Much slower, but may work better
AlternateUUIDLookup: false
# Shouldn't need to change this
AutoKillInvs: true
# Count fake votes
# If true fake votes will give points and totals
CountFakeVotes: true
@@ -840,6 +522,10 @@ CountFakeVotes: true
# Requires restart to take affect
GiveDefaultPermission: true
# Permissions given by VotingPlugin.Player by default
# Permissions listed here will no be accessible with the default permission
DisabledDefaultPermissions: []
# Remove old player files
# Happens on startup or /av purge
PurgeOldData: false
@@ -847,9 +533,92 @@ PurgeOldData: false
# Minimum number of days offline in order to purge
PurgeMin: 90
# Whether or not to disable checking names on mojang, disable if you hit the rate limit
# Shouldn't make a noticeable impact if set to false
CheckNameMojang: false
# Whether or not to create daily backups. (Only the most recent ones get kept)
CreateBackups: true
# Whether or not to create daily backups. (Only the most recent ones get saved)
CreateBackups: true
# If true, plugin will automaticly generate votesites
# Disable this if you experience issues with sites being created randomly
# Most cases this will work all the time
AutoCreateVoteSites: true
# Automaticly download the latest version
# Will require a restart to actually update
# Note: It takes 30-40 minutes before being able to download the latest build
# You can also use /av download
AutoDownload: false
# Whether or not to disable update checks
DisableUpdateChecking: false
# Allow transfer of vote points between players
AllowVotePointTransfers: false
# Disable this on a hub server for example
# Still processes rewards for offline rewards (just won't give any)
ProcessRewards: true
# Disable checking permissions on tab complete
DisableAdvancedTab: false
# Load command aliases, such as /avgui
# Requires restart to take effect
LoadCommandAliases: true
# Wait until user is logged in with AuthMe
# Requires AuthMe
WaitUntilLoggedIn: true
# Preload skulls to improve performance
# If false, skulls will be cached as they are used
PreloadSkulls: false
# Setting to false disables saving skulls in a cache to improve speeds
# Will reduce ram usage if disabled
LoadSkulls: true
# Use vault for permission checks
# May not work on some plugins
UseVaultPermissions: false
# List of disabled commands from /vote
# List the specific permission
# E.g:
# - PERMISSION
DisabledCommands: []
# Enable Geyser prefix support
GeyserPrefixSupport: false
GeyserPrefix: '*'
# Enable to true for extra player checks
ExtraBackgroundUpdate: false
# This will prevent spam clicking GUI's to prevent exploits
# Number is time in between clicking in milliseconds
SpamClickTime: 350
# Message to send when inventory forced closed when spam clicking
# Uncomment to use
#SpamClickMessage: '&cDetected spam clicking GUI, closing to prevent exploits'
# ###############################################################
# Deprecated options, don't recommend using any of these
# Will force GUI's to close on every click
AlwaysCloseInventory: false
# Options for request api
# Current methods:
# ANVIL
# BOOK
# CHAT
# This is mainly used for admin gui's to type in values
RequestAPI:
DefaultMethod: 'Anvil'
DisabledMethods: []
# Shouldn't need to change this
#AutoKillInvs: true
# Disable checking on world change
# May improve performance
#DisableCheckOnWorldChange: false
+349
View File
@@ -0,0 +1,349 @@
# Configure GUI's here
# Note: Slots start at 0 instead of 1, max slot is 53 (don't go over) (E.g: last slot in first row of inventory is 8)
# Item Material's can be found here: https://hub.spigotmc.org/javadocs/spigot/org/bukkit/Material.html
#
# GUI Methods:
# - BOOK
# - CHEST
# - CHAT (Disables GUI)
GUIMethod:
Today: CHEST #BOOK not available (future update?)
TopVoter: CHEST #BOOK not available (future update?)
Last: CHEST #BOOK not available (future update?)
Next: CHEST
Total: CHEST #BOOK not available (future update?)
URL: CHEST
Best: CHEST #BOOK not available (future update?)
Streak: CHEST #BOOK not available (future update?)
GUI: CHEST #CHAT/BOOK not availabe for this (future update?)
# Enable command for last month gui
# Requires restart to take effect
LastMonthGUI: false
CHEST:
# GUI for /vote gui, /vgui, /votegui
VoteGUI:
# Items will be ordered as listed here
# You can add items following this format, even set slots
# See extra item below. GUI will auto resize to what is needed
URL:
# Standard item format, lore is automaticly applied
Item:
Material: 'BOW'
Amount: 1
Name: '&4URL'
Lore:
- '&aClick me for links'
# You can set skulls of the player using the following
# Remove the # to enable
#Skull: '%Player%'
Next:
Item:
Material: 'COMPASS'
Amount: 1
Name: '&4Next'
Last:
Item:
Material: 'CLOCK'
Amount: 1
Name: '&4Last'
Total:
Item:
Material: 'CHEST'
Amount: 1
Name: '&4Total'
Top:
Item:
Material: 'OAK_SIGN'
Amount: 1
Name: '&4Top'
Today:
Item:
Material: 'BOOK'
Amount: 1
Name: '&4Today'
Shop:
Item:
Material: 'DIAMOND'
Amount: 1
Name: '&4Vote Shop'
Lore:
- '&aYou currently have %points% points'
# 'ExtraName' below is an identifier, can be whatever
# ExtraItem:
# Item:
# Material: 'DIRT'
# Amount: 1
# Name: 'Extra item'
## Works on most GUI items
# Slot: 10
## Send rewards on click, run commands, check conditions, etc
# Rewards: []
# GUI for /vote url, /vote
VoteURL:
# GUI Name
Name: '&cVoteURL'
BackButton: true
SiteName: '&c%Name%'
SiteNameCanVote: '&a%Name%'
SeeURL: '&cClick to see URL'
NextVote: '&cCan Vote In: %Info%'
#Start slot for specific site buttons
#StartSlot: 1
ViewAllUrlsButtonEnabled: true
AllUrlsButton:
#Set slot for AllUrlsButton
#Slot: 0
RequireAllSitesVoted: true
AlreadyVotedItem:
Material: 'REDSTONE_BLOCK'
Data: 0
Amount: 1
Name: '&4All Voting Sites'
Lore:
- '&cClick Me'
CanVoteItem:
Material: 'EMERALD_BLOCK'
Data: 0
Amount: 1
Name: '&4All Voting Sites'
Lore:
- '&cClick Me'
AlreadyVotedItem:
Material: 'REDSTONE_BLOCK'
Data: 0
Amount: 1
CanVoteItem:
Material: 'EMERALD_BLOCK'
Data: 0
Amount: 1
URLText: '%VoteUrl%'
# #Add Extra items
# ExtraItems:
# Item1:
# Material: DIRT
# Amount: 1
# Slot: 1
# #Can run commands or effects
# Rewards: []
VoteLast:
Name: 'VoteLast: %player%'
BackButton: true
VoteNext:
Name: 'VoteNext: %player%'
BackButton: true
VoteToday:
Name: 'VoteToday'
Line: '&6%VoteSite% : %Time%'
IconTitle: '%player%'
BackButton: true
UseSkull: true
# If UseSkull is false, use this item
PlayerItem:
Material: 'PAPER'
Amount: 1
VoteTop:
Name: 'VoteTop %topvoter%'
BackButton: true
# Item of top voter (change material below)
Item:
Name: '&3&l%position%: &3%player%'
Lore: '&3&lVotes: &3%votes%'
# Opens main GUI of the specific player that gets clicked
OpenMainGUIOnClick: true
SwitchItem:
Name: '&3Switch TopVoter'
Lore: '&bCurrently: %Top%'
Material: 'OAK_SIGN'
Amount: 1
# 8 Slots over from the bottom left
# Bottom of GUI
Slot: 7
# Number of topvoters to display on each GUI page, must be a multiple of 9
Size: 27
# If true, /vote top will show player heads
UseSkull: true
# Item for player in GUI if use skull is false
PlayerItem:
Material: 'PAPER'
VoteTotal:
Name: 'VoteTotal: %player%'
BackButton: true
DayTotal:
Item:
Material: 'CLOCK'
Name: '&cDaily Total'
Lore: '&c&lTotal: &c%Total%'
Amount: 1
WeekTotal:
Item:
Material: 'CLOCK'
Name: '&cWeekly Total'
Lore: '&c&lTotal: &c%Total%'
Amount: 1
MonthTotal:
Item:
Material: 'CLOCK'
Name: '&cMonthly Total'
Lore: '&c&lTotal: &c%Total%'
Amount: 1
AllTimeTotal:
Item:
Material: 'CLOCK'
Name: '&cAllTime Total'
Lore: '&c&lTotal: &c%Total%'
Amount: 1
VoteBest:
Name: 'VoteBest: %player%'
DayBest:
Item:
Material: 'CLOCK'
Name: '&cDaily Best'
Lore: '&c&lBest: &c%Best%'
Amount: 1
WeekBest:
Item:
Material: 'CLOCK'
Name: '&cWeekly Best'
Lore: '&c&lBest: &c%Best%'
Amount: 1
MonthBest:
Item:
Material: 'CLOCK'
Name: '&cMonthly Best'
Lore: '&c&lBest: &c%Best%'
Amount: 1
VoteStreak:
Name: 'VoteStreak: %player%'
BackButton: false
CurrentDayStreak:
Item:
Material: 'CLOCK'
Name: '&cCurrent Daily Streak'
Lore: '&c&lStreak: &c%Streak%'
Amount: 1
CurrentWeekStreak:
Item:
Material: 'CLOCK'
Name: '&cCurrent Weekly Streak'
Lore: '&c&lStreak: &c%Streak%'
Amount: 1
CurrentMonthStreak:
Item:
Material: 'CLOCK'
Name: '&cCurrent Monthly Streak'
Lore: '&c&lStreak: &c%Streak%'
Amount: 1
HighestDayStreak:
Item:
Material: 'CLOCK'
Name: '&cHighest Daily Streak'
Lore: '&c&lStreak: &c%Streak%'
Amount: 1
HighestWeekStreak:
Item:
Material: 'CLOCK'
Name: '&cHighest Weekly Streak'
Lore: '&c&lStreak: &c%Streak%'
Amount: 1
HighestMonthStreak:
Item:
Material: 'CLOCK'
Name: '&cHighest Monthly Streak'
Lore: '&c&lStreak: &c%Streak%'
Amount: 1
VoteURLSite:
Name: 'VoteSite: %site%'
VoteGUIName: '&cVoteGUI: &c&l%player%'
VoteRewardName: 'VoteReward'
VoteShopName: 'VoteShop'
BackButton:
Material: 'BARRIER'
Data: 0
Amount: 1
Name: '&8Back to VoteGUI'
# If true, clicking back button will open VoteURL
OpenVoteURL: false
# If true, backbutton will be the last slot of the GUI
EndOfGUI: false
VoteShopBackButton: true
VoteShopEnabled: true
# Hide items in vote shop which user can not buy
VoteShopHideLimitedReached: true
# Requires above to be false
VoteShopLimitReached: '&aYou reached your limit'
VoteShopRequireConfirmation: false
VoteShopDisabled: '&cVote shop disabled'
Shop:
# Identifier
# Used in placeholders for formats
# Do not have spaces in the identifier
# Change the identifier for each shop item
Diamond:
Identifier_Name: 'Diamond'
# Item
Material: 'DIAMOND'
Amount: 1
Name: '&4Buy A Diamond'
# You can set skulls of the player using the following
# Remove the # to enable
#Skull: '%Player%'
Lore:
- '&c&lCost: &c3 Voting Points'
# Number of voting points this cost
Cost: 3
# Permission required, leave blank for no permission
Permission: ''
# Whether or not to keep GUI open after purchase
CloseGUI: true
# Require confirmation on purchase, overrides global option above
RequireConfirmation: false
# Overrides other purchase message
#PurchaseMessage: 'Thanks for the purchase'
# Limit how many times you can buy this
#Limit: 3
# Reset limit daily/weekly/monthly
#Reset:
#Daily: false
#Weekly: false
#Monthly: false
# If true, item is not buyable
#NotBuyable: false
# Rewards to run if player buys successfully
Rewards:
# Run command on purchase
#Commands:
#- 'command here'
Items:
Diamond:
Material: 'DIAMOND'
Amount: 1
ShopConfirmPurchase:
Title: 'Confirm Purchase?'
YesItem:
Material: EMERALD_BLOCK
Amount: 1
Name: '&aYes'
NoItem:
Material: BARRIER
Amount: 1
Name: '&cNo'
BOOK:
VoteURLBookGUI:
Title: '&cVoteURL'
CanVoteText: 'Click me'
CanVoteColor: 'GREEN'
AlreadyVotedText: 'Click me'
AlreadyVotedColor: 'RED'
Layout:
- '&3&l%Sitename%'
- '[UrlText]'
+198
View File
@@ -0,0 +1,198 @@
# To disable reward set value to []
# or remove entirely
# Eg:
# FirstVote: [] (All in one line)
# Rewards will be given if there is a reward to give
# First vote rewards
FirstVote:
Messages:
Player: '&aYou voted for your first time!'
# All vote rewards
# Reward for voting on all sites in one day
AllSites:
Messages:
Player: '&aYou voted on all sites in 1 day!'
# NOTE: This is not a 1 time reward, that's what milestones are for!
# If total votes (Can be changed) divided by cumulative amount
# and as no remainder (So divides perfectly)then a reward is given
Cumulative:
# Number of votes required
# Allows multiple cumulative rewards
# Number be be around ' (E.g. '1')
# Can have multiple listed here
'20':
Enabled: false
# Wether or not votes must be made in same day/week
# Useful if you want to require a certain number of voting sites to be voted on
# for a daily/weekly reward instead of all of them
VotesInSameDay: false
VotesInSameWeek: false
VotesInSameMonth: false
Rewards:
Messages:
Player: '&aYou got %cumulative% cumulative votes!'
# Vote party configuration
VoteParty:
# Wether or not vote party is enabled
Enabled: false
# Number of votes required to give rewards
VotesRequired: 20
# Increase the amount of votes required on each vote party reached
#IncreaseVotesRquired: 10
# If true, players who did not vote to reach the votes required will
# recieve the reward
# If false, only players who voted get rewards
GiveAllPlayers: false
# If true, the vote count will reset each day
ResetEachDay: false
# If true, the vote count will reset each week
ResetWeekly: false
# Reset at the end of the month
ResetMonthly: false
# If true, will give voteparty only once per day
OnlyOncePerDay: false
# Reset extra votes
ResetExtraVotesMonthly: false
# Count votes from /av vote?
CountFakeVotes: true
# Number of user votes that apply to vote party total the user needs to get rewards
UserVotesRequired: 0
# Count offline votes
CountOfflineVotes: true
# Broadcast when vote party reached
Broadcast: '&cReached the vote party amount!'
# List of commands to execute, these only execute once.
# %player% does not work here
Commands: []
# Rewards to give per player
Rewards:
# Uncomment below for online players to be rewarded only
#RewardType: ONLINE
Commands:
- say %player%
Items:
DIAMOND:
Material: 'DIAMOND'
Amount: 1
# Reset milestones at end of the month
ResetMilestonesMonthly: false
# One time reward to be given (unless you reset it somehow)
MileStones:
# Number of votes required
# Allows multiple milestones
# Number be around ' (E.g. '1')
# Can have multiple listed here
'20':
Enabled: false
Rewards:
Messages:
Player: '&aYou got %milestone% milestone votes!'
VoteStreak:
# Valid options: Day, Week, Month
Day:
# Number of days in a row
# Each day requires one vote
# Add a - to give a reward for every multiple (e.g. 2- = 2,4,6,8, and so on)
'2':
# Enabled or not
Enabled: false
# Rewards to give
Rewards:
Messages:
Player: "&aYou voted for %Streak% %Type%'s in a row!"
Week:
# Number of weeks in a row
# Requires atleast one vote per week
'2':
# Enabled or not
Enabled: false
# Rewards to give
Rewards:
Messages:
Player: "&aYou voted for %Streak% %Type%'s in a row!"
Month:
# Number of months in a row
# Requires atleast 1 vote per month
'2':
# Enabled or not
Enabled: false
# Rewards to give
Rewards:
Messages:
Player: "&aYou voted for %Streak% %Type%'s in a row!"
Requirement:
# Require certain percentage of votes
UsePercentage: false
# Percentage requirements of votes
# 50 = %50
Day: 50
Week: 50
Month: 50
# Reward given when vote cooldown ended
# Using this is a little memory intensive
VoteCoolDownEndedReward: []
# ONLY USE THIS FOR TITLES/SOUNDS AND OTHER EFFECTS
# IT WILL ONLY RUN ONE TIME FOR ANY NUMBER OF OFFLINE VOTES (3 offline votes = 1 AnySiteReward)
# Any reward files listed here are ran on vote of any site
# It is recommended to add rewards to each site instead of here
# Using forceoffline won't work here
# Use EverySiteReward in VoteSites.yml for a global reward for each site
AnySiteRewards: {}
# Rewards to run when player logs in
LoginRewards: {}
# Rewards to run when player logs off
# Will queue until player logs in unless forceoffline is enabled
LogoutRewards: {}
EnableMonthlyAwards: true
# Rewards to give
MonthlyAwards:
# Position. 1 is first in top voter, 2 is second, etc...
# Using 1-10 will reward players in first to tenth place with the same reward
1:
Rewards:
Messages:
Player: '&aYou came in first place in %TopVoter%!'
2:
Rewards:
Messages:
Player: '&aYou came in second place in %TopVoter%!'
EnableWeeklyAwards: false
# Rewards to give on weekly top voter
WeeklyAwards:
# Position. 1 is first in top voter, 2 is second, etc...
1:
Rewards:
Messages:
Player: '&aYou came in first place in %TopVoter%!'
2:
Rewards:
Messages:
Player: '&aYou came in second place in %TopVoter%!'
EnableDailyRewards: false
# Rewards to give on daily top voter
DailyAwards:
# Position. 1 is first in top voter, 2 is second, etc...
1:
# Reward files to give
Rewards:
Messages:
Player: '&aYou came in first place in %TopVoter%!'
2:
Rewards:
Messages:
Player: '&aYou came in second place in %TopVoter%!'
+73 -6
View File
@@ -1,5 +1,7 @@
VoteSites:
# VoteSite name
# VoteSite key
# Used for saving data for votesites
# Use a short name if you can
ExampleVoteSite:
# Enable voteSite
# If false, votesite will not be loaded by plugin
@@ -13,44 +15,109 @@ VoteSites:
# Used for sorted list
# High prority, higher on the list
Priority: 5
# If true, voteside will be hidden from some GUI's, similar to being disabled
Hidden: false
# The serviceName from the vote, has to be correct to work correctly
# Gotten from voting on the site (will be in console/log)
# Usually is the main part of the url(e.g. PlanetMinecraft.com)
# Usually is the main part of the url(e.g. PlanetMinecraft.com), but not always
# See console when you vote (it will notify you if the plugin didn't find a votingsite matching the service site
ServiceSite: 'PlanetMinecraft.com'
# vote url for /vote
# Format for this can be set in Format.yml
# Do not include colors here
# If you need to force a url set the url as this:
# VoteURL: '[Text="ANY TEXT TO CLICK ON HERE",url="URLHERE"]'
VoteURL: 'link to vote URL here, used in /vote'
# Time between votes in hours (used for /vote next)
# Most sites are 24 hours
VoteDelay: 24
# Use to have a minute votedelay
#VoteDelayMin: 30
# Require waiting until votedelay time has pasted in order to accept vote
# Recommend: false
WaitUntilVoteDelay: false
# Reset vote delay each day (for certain sites that do this)
# Recommend: false
VoteDelayDaily: false
#Offset time for /vote next caculations
#TimeOffSet: 0
# If true, rewards can be executed offline (requires ForceOffline to be true in the reward)
# Setting this to true will execute the reward offline, NOT WHEN THE PLAYER IS OFFLINE
# Setting this to true will execute the reward offline while the player is offline
# This basiclly disables offline voting if set to true, don't misinterpret this option
ForceOffline: false
# VoteSite Material for GUI's
# VoteSite Material for some GUI's
# Removing this may result in an error, required on each site
Item:
DisplayItem:
Material: 'DIAMOND'
Amount: 1
# Rewards to give
# https://github.com/Ben12345rocks/AdvancedCore/wiki/Rewards
Rewards:
# Execute console commands
Commands:
- 'say hello'
# Send player a message
Messages:
Player: 'You voted'
# Site 2 example
Site2:
Enabled: false
Name: 'Site2'
ServiceSite: 'PlanetMinecraft.com'
VoteURL: 'link to vote URL here, used in /vote'
VoteDelay: 24
DisplayItem:
Material: 'DIAMOND'
Amount: 1
Rewards:
Commands:
- 'say hello'
# Advanced example
# 50% chance for reward1, if reward1 not given then 20% chance to get reward2, if reward2 not given then fallback
AdvancedPriority:
# Similar to priority, but no need to have to use reward files
# Add requirements under each reward
# Will go in order from list here and try to run each of the following rewards...
# This name can be anything, but they need to be different
Reward1:
Chance: 50
# Any other requirement here
# If any requirement fails, the next reward will be attempted
# Use permission requirement for rank based rewards
#RequirePermission: true
#Permission: 'permhere'
Messages:
Player: 'You got first reward'
Reward2:
Chance: 20
Messages:
Player: 'You got second reward'
# Fallback, 100% chance, after other rewards fail chances
Fallback:
Messages:
Player: 'You got unlucky'
# Give 1 diamond
Items:
item1:
Material: DIAMOND
Amount: 1
Messages:
Player: 'You voted'
# Reward for any site
# Similar to AnySiteReward
# This requires the site to be configured in order to get the reward.
EverySiteReward: []
EverySiteReward: {}
+4
View File
@@ -0,0 +1,4 @@
name: ${project.name}
version: ${project.version}
main: com.bencodez.votingplugin.bungee.VotingPluginBungee
author: BenCodez
+85
View File
@@ -0,0 +1,85 @@
# Set bungeecoord to true on servers on the network (In VotingPlugin)
# Set server name in each server related to what it is on bungee
#
# MYSQL Required on all setups
# MYSQL INFO --------------------------
Host: ''
# Default port is 3306
Port: 3306
Database: ''
Username: ''
Password: ''
# Max number of connections
MaxConnections: 1
# Maxium size of caching mysql
# -1 for no limit
# Affecting this value may affect performance
MaxSize: -1
# Table name prefix, for use with mutliple servers
Prefix: ''
#UseSSL: true
#PublicKeyRetrieval: false
Debug: false
# Have a reward on each server
# If false, will send to online server only
SendVotesToAllServers: true
# List of servers the plugin won't send the vote to
# Uses names from bungeecoord config if not using SOCKETS method
BlockedServers:
- hub
# What type of bungee setup
# Requires restart and set on all servers
# https://github.com/Ben12345rocks/VotingPlugin/wiki/Bungeecoord-Setups
# Available:
# SOCKETS
# PLUGINMESSAGING
# MYSQL
BungeeMethod: PLUGINMESSAGING
# If false, votes will be checked if user is a valid player that has joined to server
# Works for PLUGINMESSAGING and SOCKETS methods only
# This requires spigot servers AllowUnJoined to be set to true in Config.yml
AllowUnJoined: false
# If true, bungee will handle adding totals
# If false, spigot servers will EACH set their own totals
# If false, AllowUnJoined should false on bungee, spigot servers will handle that
# Recommened to leave true, setting to false setups are currently unsupported
BungeeManageTotals: true
# ----------------------------
# PLUGINMESSAGING Settings
# ----------------------------
# Applies to PLUGINMESSAGING & when SendVotesToAllServers is true
# Votes will be forwarded when specific player is online
WaitForUserOnline: false
# ----------------------------
# SOCKET Settings, do not touch otherwise
# ----------------------------
# Tell servers to broadcast
# For socket method
Broadcast: true
# Server to send vote to if player is offline
FallBackServer: factions
# Bungee communication, Add this to each spigot server
# For socket method
BungeeServer:
Host: '127.0.0.1'
Port: 1297
# Bungee communication, add each spigot server here
# For socket method
SpigotServers:
lobby:
Host: '127.0.0.1'
Port: 1298
factions:
Host: '127.0.0.1'
Port: 1999
+78 -49
View File
@@ -1,10 +1,10 @@
name: ${project.name}
version: ${project.version}
main: com.Ben12345rocks.VotingPlugin.Main
main: com.bencodez.votingplugin.VotingPluginMain
description: Highly Customizable Voting Listener!
website: https://www.spigotmc.org/resources/votingplugin.15358/
author: Ben12345rocks
softdepend: [AdvancedCore]
author: BenCodez
softdepend: [MVdWPlaceholders, Votifier, VotifierPlus, NuVotifier, CMI, Vault, PlaceholderAPI, ProtocolLib, MVdWPlaceholderAPI, AuthMe]
api-version: 1.13
commands:
vote:
@@ -28,9 +28,6 @@ commands:
votetop:
description: See top voters
aliases: vtop
voteinfo:
description: See player info
aliases: vinfo
votetoday:
description: See who voted today
aliases: vtoday
@@ -58,21 +55,30 @@ commands:
votestreak:
description: A command
aliases: vstreak
votetogglebroadcast:
description: A command
aliases: vtogglebroadcast
votepoints:
description: A command
aliases: vpoints
votegivereward:
votelist:
description: A command
voteselectChoiceReward:
aliases: vlist
voteall:
description: A command
aliases: vall
votechoices:
description: A command
alaises: vchoices
votegivepoints:
description: A command
alaises: vgivepoints
adminvotehelp:
description: Open adminvote help
aliases: avhelp
adminvote?:
description: Open adminvote help
aliases: av?
adminvoteconvert:
description: A command
adminvotereport:
description: Command Alias
aliases: avreport
@@ -85,6 +91,9 @@ commands:
adminvotereload:
description: Command Alias
aliases: avreload
adminvotetestreward:
description: Command Alias
aliases: avtestreward
adminvoteversion:
description: Command Alias
aliases: avversion
@@ -94,81 +103,58 @@ commands:
adminvoterewards:
description: Command Alias
aliases: avrewards
adminvotereward:
description: Command Alias
aliases: avreward
adminvoteuuid:
description: Command Alias
aliases: avuuid
adminvotereset:
description: Command Alias
aliases: avreset
adminvotevotesite:
description: Command Alias
aliases: avvotesite
adminvoteconfig:
description: Command Alias
aliases: avconfig
adminvoteserverdata:
description: Command Alias
aliases: avserverdata
adminvotesettotal:
description: Command Alias
aliases: avsettotal
adminvoteupdatecheck:
description: Command Alias
aliases: avupdatecheck
adminvotevote:
description: Command Alias
aliases: [avvote, fakevote]
adminvoteTriggerPlayerVoteEvent:
description: Command Alias
aliases: avTriggerPlayerVoteEvent
adminvotesetpoints:
description: Command Alias
aliases: avsetpoints
adminvoteaddpoints:
description: Command Alias
aliases: avaddpoints
adminvotegui:
description: Command Alias
aliases: avgui
votesetrequestmethod:
description: Command Alias
aliases: [vsetrequestmethod, setrequesetmethod]
adminvotegivereward:
description: Command Alias
aliases: avgivereward
adminvoteusers:
description: Command Alias
aliases: avusers
adminvoteClearTotal:
description: Command Alias
aliases: avClearTotal
adminvoteConvertFromData:
description: Command Alias
aliases: avConvertFromData
adminvoteClearTotal:
description: Command Alias
aliases: avClearTotal
adminvoteBackgroundUpdate:
description: Command Alias
aliases: avBackgroundUpdate
adminvoteClearCache:
description: Command Alias
aliases: avClearCache
adminvoteConvertFrom:
description: Command Alias
aliases: avConvertFrom
adminvoteRemovePoints:
description: Command Alias
aliases: avRemovePoints
adminvoteServiceSites:
description: Command Alias
aliases: avServiceSites
adminvoteSetVotePartyCount:
description: Command Alias
aliases: avSetVotePartyCount
adminvoteChoices:
description: Command Alias
aliases: avChoices
adminvoteReloadAll:
description: Command Alias
aliases: avReloadAll
adminvotePermsPlayer:
description: Command Alias
aliases: avPermsPlayer
adminvoteResyncMilestonesAlreadyGiven:
description: Command Alias
aliases: avResyncMilestonesAlreadyGiven
voteSetPrimaryAccount:
description: Command Alias
adminvoteClearOfflineVotes:
description: Command Alias
aliases: avClearOfflineVotes
@@ -199,13 +185,47 @@ commands:
adminvoteJavascript:
description: Command Alias
aliases: avJavascript
adminvoteStatus:
description: Command Alias
aliases: avStatus
adminvoteTest:
description: Command Alias
aliases: avTest
adminvotePlaceholders:
description: Command Alias
aliases: avPlaceholders
adminvoteDownloadJenkins:
description: Command Alias
aliases: avDownloadJenkins
adminvoteForceVoteParty:
description: Command Alias
aliases: avForceVoteParty
adminvoteSetRequestMethod:
description: Command Alias
aliases: avSetRequestMethod
adminvoteUser:
description: Command Alias
aliases: avUser
adminvoteCurrentPluginTime:
description: Command Alias
aliases: avCurrentPluginTime
adminvoteResetPoints:
description: Command Alias
aliases: avResetPoints
adminvoteVotePartyExtraRequired:
description: Command Alias
aliases: avVotePartyExtraRequired
adminvoteRunCMD:
description: Command Alias
aliases: avRunCMD
permissions:
VotingPlugin.Player:
description: Allows basic access player commands
VotingPlugin.Mod:
description: Allows mod access player commands
description: Allows mod commands
VotingPlugin.Admin:
description: Allows admin access player commands
description: Allows admincommands
VotingPlugin.Login.RemindVotes:
description: Allows players to get remined on login if they can vote
default: true
@@ -218,4 +238,13 @@ permissions:
VotingPlugin.NoRemind:
description: Ignore vote reminding
default: false
VotingPlugin.Sign.Create:
description: Permission to create sign
VotingPlugin.Admin.GenerateServiceSite:
description: Permission for generating votesite message
VotingPlugin.Login.RemindVotes:
description: Permission to allow timed reminders
VotingPlugin.Login.RemindVotes.Any:
description: Remind if player can vote on any website, rather than all
default: false
@@ -0,0 +1,2 @@
time: '${timestamp}'
profile: ${build.profile.id}
+201 -40
View File
@@ -1,15 +1,17 @@
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.Ben12345rocks</groupId>
<artifactId>VotingPlugin</artifactId>
<version>5.13.5</version>
<groupId>com.bencodez</groupId>
<artifactId>VotingPlugin</artifactId>
<version>6.3</version>
<packaging>jar</packaging>
<name>VotingPlugin</name>
<properties>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<github.global.server>github</github.global.server>
<project.build.sourceEncoding>Cp1252</project.build.sourceEncoding>
</properties>
<distributionManagement>
<repository>
@@ -25,6 +27,8 @@
<filtering>true</filtering>
<includes>
<include>plugin.yml</include>
<include>bungee.yml</include>
<include>votingpluginversion.yml</include>
</includes>
</resource>
<resource>
@@ -33,6 +37,34 @@
</resource>
</resources>
<sourceDirectory>src</sourceDirectory>
<pluginManagement>
<plugins>
<plugin>
<groupId>org.eclipse.m2e</groupId>
<artifactId>lifecycle-mapping</artifactId>
<version>1.0.0</version>
<configuration>
<lifecycleMappingMetadata>
<pluginExecutions>
<pluginExecution>
<pluginExecutionFilter>
<groupId>org.projectlombok</groupId>
<artifactId>lombok-maven-plugin</artifactId>
<versionRange>[1,)</versionRange>
<goals>
<goal>delombok</goal>
</goals>
</pluginExecutionFilter>
<action>
<ignore />
</action>
</pluginExecution>
</pluginExecutions>
</lifecycleMappingMetadata>
</configuration>
</plugin>
</plugins>
</pluginManagement>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
@@ -44,36 +76,60 @@
<finalName>${project.name}</finalName>
</configuration>
</plugin>
<plugin>
<groupId>org.projectlombok</groupId>
<artifactId>lombok-maven-plugin</artifactId>
<version>1.18.12.0</version>
<executions>
<execution>
<id>delombok</id>
<phase>deploy</phase>
<goals>
<goal>delombok</goal>
</goals>
<configuration>
<addOutputDirectory>false</addOutputDirectory>
<outputDirectory>${project.basedir}/target/delombok</outputDirectory>
<sourceDirectory>${project.basedir}/src</sourceDirectory>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>2.4.3</version>
<configuration>
<shadedArtifactAttached>false</shadedArtifactAttached>
<minimizeJar>true</minimizeJar>
<relocations>
<!-- Lets relocate the shaded API so we dont cause any conflicts with
other plugins -->
<relocation>
<pattern>com.Ben12345rocks.AdvancedCore</pattern>
<shadedPattern>${project.groupId}.${project.artifactId}.AdvancedCore</shadedPattern>
<pattern>com.bencodez.advancedcore</pattern>
<shadedPattern>${project.groupId}.votingplugin.advancedcore</shadedPattern>
</relocation>
<!-- Lets relocate the shaded API so we dont cause any conflicts with
other plugins -->
<relocation>
<pattern>net.pl3x.bukkit.chatapi</pattern>
<shadedPattern>${project.groupId}.${project.artifactId}</shadedPattern>
<shadedPattern>${project.groupId}.votingplugin</shadedPattern>
</relocation>
<relocation>
<pattern>me.mrten.mysqlapi</pattern>
<shadedPattern>${project.groupId}.${project.artifactId}.mysqlapi</shadedPattern>
<shadedPattern>${project.groupId}.votingplugin.mysqlapi</shadedPattern>
</relocation>
<relocation>
<pattern>com.zaxxer.HikariCP</pattern>
<shadedPattern>${project.groupId}.${project.artifactId}.HikariCP</shadedPattern>
<shadedPattern>${project.groupId}.votingplugin.HikariCP</shadedPattern>
</relocation>
<relocation>
<pattern>org.slf4j.slf4j-simple</pattern>
<shadedPattern>${project.groupId}.${project.artifactId}.slf4j-simple</shadedPattern>
<pattern>com.zaxxer.hikari</pattern>
<shadedPattern>${project.groupId}.votingplugin.hikari</shadedPattern>
</relocation>
<relocation>
<pattern>xyz.upperlevel.spigot.book</pattern>
<shadedPattern>${project.groupId}.votingplugin.upperlevel.book</shadedPattern>
</relocation>
</relocations>
</configuration>
@@ -92,7 +148,6 @@
</excludes>
</artifactSet>
<createDependencyReducedPom>false</createDependencyReducedPom>
</configuration>
</execution>
</executions>
@@ -108,6 +163,9 @@
<goal>jar</goal>
</goals>
<phase>deploy</phase>
<configuration>
<sourcepath>${project.basedir}/target/delombok</sourcepath>
</configuration>
</execution>
</executions>
</plugin>
@@ -132,12 +190,37 @@
<include>**/*</include>
</includes>
<repositoryName>VotingPlugin</repositoryName>
<repositoryOwner>Ben12345rocks</repositoryOwner>
<repositoryOwner>BenCodez</repositoryOwner>
<server>github</server>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>3.1.0</version>
<executions>
<execution>
<id>copy-resources</id>
<phase>install</phase>
<goals>
<goal>copy-resources</goal>
</goals>
<configuration>
<outputDirectory>${user.home}/Documents/Test Server/plugins</outputDirectory>
<resources>
<resource>
<directory>${basedir}/target</directory>
<includes>
<include>VotingPlugin.jar</include>
</includes>
</resource>
</resources>
<overwrite>true</overwrite>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
<repositories>
@@ -145,49 +228,127 @@
<id>spigot-repo</id>
<url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
</repository>
<repository>
<id>jitpack.io</id>
<url>https://jitpack.io</url>
<snapshots>
<enabled>true</enabled>
<updatePolicy>always</updatePolicy>
</snapshots>
<id>maven-central</id>
<url>https://oss.sonatype.org/content/groups/public</url>
</repository>
<repository>
<id>bungeecord-repo</id>
<url>https://oss.sonatype.org/content/repositories/snapshots</url>
</repository>
<repository>
<id>velocity</id>
<url>https://nexus.velocitypowered.com/repository/maven-public/</url>
</repository>
<repository>
<id>bintray-repo</id>
<url>https://dl.bintray.com/ichbinjoe/public/</url>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>com.github.Ben12345rocks</groupId>
<artifactId>AdvancedCore</artifactId>
<version>master-SNAPSHOT</version>
</dependency>
<!-- <dependency> <groupId>com.Ben12345rocks</groupId> <artifactId>AdvancedCore</artifactId>
<version>LATEST</version> <scope>compile</scope> </dependency> -->
<!--<dependency> <groupId>com.github.Ben12345rocks</groupId> <artifactId>AdvancedCore</artifactId>
<version>3.0-SNAPSHOT</version> </dependency> -->
<dependency>
<groupId>org.spigotmc</groupId>
<artifactId>spigot-api</artifactId>
<version>1.12.2-R0.1-SNAPSHOT</version>
<version>1.16.5-R0.1-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.2</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>net.md-5</groupId>
<artifactId>bungeecord-api</artifactId>
<version>LATEST</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.vexsoftware</groupId>
<artifactId>votifier</artifactId>
<version>1.9</version>
<scope>system</scope>
<systemPath>${project.basedir}/Jars/Votifier.jar</systemPath>
<artifactId>nuvotifier-universal</artifactId>
<version>2.6.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.swifteh</groupId>
<artifactId>GAL</artifactId>
<version>1.3.2</version>
<scope>system</scope>
<systemPath>${project.basedir}/Jars/GAListener.jar</systemPath>
<groupId>com.tchristofferson</groupId>
<artifactId>ConfigUpdater</artifactId>
<version>1.1-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.mythicacraft</groupId>
<artifactId>voteroulette</artifactId>
<version>3.2.2</version>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.5.6</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>be.maximvdw</groupId>
<artifactId>MVdWPlaceholderAPI</artifactId>
<version>LATEST</version>
<scope>system</scope>
<systemPath>${project.basedir}/Jars/VoteRoulette.jar</systemPath>
<systemPath>${project.basedir}/Jars/MVdWPlaceholderAPI.jar</systemPath>
</dependency>
</dependencies>
<profiles>
<profile>
<id>prod</id>
<activation>
<activeByDefault>true</activeByDefault>
</activation>
<properties>
<build.profile.id>prod</build.profile.id>
</properties>
<dependencies>
<dependency>
<groupId>com.github.bencodez</groupId>
<artifactId>advancedcore</artifactId>
<version>master-SNAPSHOT</version>
</dependency>
</dependencies>
<repositories>
<repository>
<id>jitpack.io</id>
<url>https://jitpack.io</url>
<snapshots>
<enabled>true</enabled>
<updatePolicy>always</updatePolicy>
</snapshots>
</repository>
</repositories>
</profile>
<profile>
<id>prod2</id>
<properties>
<build.profile.id>prod2</build.profile.id>
</properties>
<dependencies>
<dependency>
<groupId>com.bencodez</groupId>
<artifactId>AdvancedCore</artifactId>
<version>LATEST</version>
<scope>compile</scope>
</dependency>
</dependencies>
</profile>
<profile>
<id>dev</id>
<properties>
<build.profile.id>dev</build.profile.id>
</properties>
<dependencies>
<dependency>
<groupId>com.bencodez</groupId>
<artifactId>AdvancedCore</artifactId>
<version>LATEST</version>
<scope>compile</scope>
</dependency>
</dependencies>
</profile>
</profiles>
</project>
File diff suppressed because it is too large. Load diff
@@ -1,851 +0,0 @@
package com.Ben12345rocks.VotingPlugin.Commands;
import java.text.SimpleDateFormat;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.permissions.Permission;
import com.Ben12345rocks.AdvancedCore.AdvancedCoreHook;
import com.Ben12345rocks.AdvancedCore.Objects.CommandHandler;
import com.Ben12345rocks.AdvancedCore.Objects.UUID;
import com.Ben12345rocks.AdvancedCore.Util.Misc.ArrayUtils;
import com.Ben12345rocks.AdvancedCore.Util.Misc.MiscUtils;
import com.Ben12345rocks.AdvancedCore.Util.Misc.StringUtils;
import com.Ben12345rocks.AdvancedCore.Util.Scoreboards.SimpleScoreboard;
import com.Ben12345rocks.VotingPlugin.Main;
import com.Ben12345rocks.VotingPlugin.Config.Config;
import com.Ben12345rocks.VotingPlugin.Config.ConfigVoteSites;
import com.Ben12345rocks.VotingPlugin.Objects.User;
import com.Ben12345rocks.VotingPlugin.Objects.VoteSite;
import com.Ben12345rocks.VotingPlugin.UserManager.UserManager;
import net.md_5.bungee.api.chat.TextComponent;
// TODO: Auto-generated Javadoc
/**
* The Class Commands.
*/
public class Commands {
/** The config. */
static Config config = Config.getInstance();
/** The config vote sites. */
static ConfigVoteSites configVoteSites = ConfigVoteSites.getInstance();
/** The instance. */
static Commands instance = new Commands();
/** The plugin. */
static Main plugin = Main.plugin;
/**
* Gets the single instance of Commands.
*
* @return single instance of Commands
*/
public static Commands getInstance() {
return instance;
}
/**
* Instantiates a new commands.
*/
private Commands() {
}
/**
* Instantiates a new commands.
*
* @param plugin
* the plugin
*/
public Commands(Main plugin) {
Commands.plugin = plugin;
}
/**
* Admin help.
*
* @param sender
* the sender
* @param page
* the page
* @return the array list
*/
public ArrayList<TextComponent> adminHelp(CommandSender sender, int page) {
int pagesize = Config.getInstance().getFormatPageSize();
ArrayList<TextComponent> msg = new ArrayList<TextComponent>();
ArrayList<TextComponent> text = adminHelpText(sender);
int maxPage = text.size() / pagesize;
if ((text.size() % pagesize) != 0) {
maxPage++;
}
msg.add(StringUtils.getInstance().stringToComp("&3&lVotingPlugin Admin Help " + (page + 1) + "/" + maxPage));
msg.add(StringUtils.getInstance().stringToComp("&3&l() = Needed"));
msg.add(StringUtils.getInstance().stringToComp("&3&lAliases: adminvote, av"));
for (int i = pagesize * page; (i < text.size()) && (i < ((page + 1) * pagesize) - 1); i++) {
msg.add(text.get(i));
}
return msg;
}
/**
* Admin help text.
*
* @param sender
* the sender
* @return the array list
*/
public ArrayList<TextComponent> adminHelpText(CommandSender sender) {
ArrayList<TextComponent> msg = new ArrayList<TextComponent>();
HashMap<String, TextComponent> unsorted = new HashMap<String, TextComponent>();
boolean requirePerms = Config.getInstance().getFormatCommandsVoteHelpRequirePermission();
for (CommandHandler cmdHandle : plugin.adminVoteCommand) {
if (sender.hasPermission(cmdHandle.getPerm()) && requirePerms) {
unsorted.put(cmdHandle.getHelpLineCommand("/adminvote"), cmdHandle.getHelpLine("/adminvote"));
} else {
unsorted.put(cmdHandle.getHelpLineCommand("/adminvote"), cmdHandle.getHelpLine("/adminvote"));
}
}
ArrayList<String> unsortedList = new ArrayList<String>();
unsortedList.addAll(unsorted.keySet());
Collections.sort(unsortedList, String.CASE_INSENSITIVE_ORDER);
for (String cmd : unsortedList) {
msg.add(unsorted.get(cmd));
}
return msg;
}
public String[] best(CommandSender sender, String name) {
ArrayList<String> msg = new ArrayList<String>();
msg.add(config.getFormatCommandsVoteBestTitle());
msg.addAll(config.getFormatCommandsVoteBestLines());
User user = UserManager.getInstance().getVotingPluginUser(name);
HashMap<String, String> placeholders = new HashMap<String, String>();
placeholders.put("HighestDailyTotal", "" + user.getHighestDailyTotal());
placeholders.put("HighestWeeklyTotal", "" + user.getHighestWeeklyTotal());
placeholders.put("HighestMonthlyTotal", "" + user.getHighestMonthlyTotal());
placeholders.put("player", name);
msg = ArrayUtils.getInstance().replacePlaceHolder(msg, placeholders);
return ArrayUtils.getInstance().convert(ArrayUtils.getInstance().colorize(msg));
}
/**
* Command vote today.
*
* @param page
* the page
* @return the string[]
*/
public String[] commandVoteToday(int page) {
int pagesize = Config.getInstance().getFormatPageSize();
if (page < 1) {
page = 1;
}
ArrayList<String> msg = new ArrayList<String>();
String[] voteToday = voteToday();
int maxPage = voteToday.length / pagesize;
if ((voteToday.length % pagesize) != 0) {
maxPage++;
}
msg.add("&cToday's Votes " + page + "/" + maxPage);
msg.add("&cPlayerName : VoteSite : Time");
page--;
for (int i = pagesize * page; (i < voteToday.length) && (i < ((page + 1) * pagesize)); i++) {
msg.add(voteToday[i]);
}
msg = ArrayUtils.getInstance().colorize(msg);
return ArrayUtils.getInstance().convert(msg);
}
public String[] listPerms(CommandSender sender) {
ArrayList<String> msg = new ArrayList<String>();
msg.add("&c&lCommand : Permissions (seperated by |)");
for (CommandHandler handle : plugin.voteCommand) {
if (sender instanceof Player) {
if (handle.hasPerm(sender)) {
msg.add("&a" + handle.getHelpLineCommand("/vote") + " : " + handle.getPerm() + " : true");
} else {
msg.add("&c" + handle.getHelpLineCommand("/vote") + " : " + handle.getPerm() + " : false");
}
} else {
msg.add(handle.getHelpLineCommand("/vote") + " : " + handle.getPerm());
}
}
for (CommandHandler handle : plugin.adminVoteCommand) {
if (sender instanceof Player) {
if (handle.hasPerm(sender)) {
msg.add("&a" + handle.getHelpLineCommand("/av") + " : " + handle.getPerm() + " : true");
} else {
msg.add("&c" + handle.getHelpLineCommand("/av") + " : " + handle.getPerm() + " : false");
}
} else {
msg.add(handle.getHelpLineCommand("/av") + " : " + handle.getPerm());
}
}
for (Permission perm : plugin.getDescription().getPermissions()) {
if (sender instanceof Player) {
if (sender.hasPermission(perm)) {
msg.add("&a" + perm.getName() + " : true");
} else {
msg.add("&c" + perm.getName() + " : false");
}
} else {
msg.add(perm.getName());
}
}
msg = ArrayUtils.getInstance().colorize(msg);
return ArrayUtils.getInstance().convert(msg);
}
public void listPerms(CommandSender sender, String player, int page) {
Player p = Bukkit.getPlayer(player);
if (p != null) {
ArrayList<String> msg = new ArrayList<String>();
ArrayList<String> text = new ArrayList<String>();
for (CommandHandler handle : plugin.voteCommand) {
if (handle.hasPerm(p)) {
msg.add("&a" + handle.getHelpLineCommand("/vote") + " : " + handle.getPerm() + " : true");
} else {
msg.add("&c" + handle.getHelpLineCommand("/vote") + " : " + handle.getPerm() + " : false");
}
}
for (CommandHandler handle : plugin.adminVoteCommand) {
if (handle.hasPerm(p)) {
msg.add("&a" + handle.getHelpLineCommand("/av") + " : " + handle.getPerm() + " : true");
} else {
msg.add("&c" + handle.getHelpLineCommand("/av") + " : " + handle.getPerm() + " : false");
}
}
for (Permission perm : plugin.getDescription().getPermissions()) {
if (p.hasPermission(perm)) {
msg.add("&a" + perm.getName() + " : true");
} else {
msg.add("&c" + perm.getName() + " : false");
}
}
msg = ArrayUtils.getInstance().colorize(msg);
int pagesize = Config.getInstance().getFormatPageSize();
int maxPage = msg.size() / pagesize;
if ((msg.size() % pagesize) != 0) {
maxPage++;
}
text.add("&c&lCommand : Permissions (seperated by |) " + page + "/" + maxPage);
for (int i = pagesize * page - pagesize; i < msg.size() && i < pagesize * page; i++) {
text.add(msg.get(i));
}
sender.sendMessage(ArrayUtils.getInstance().convert(ArrayUtils.getInstance().colorize(text)));
} else {
sender.sendMessage(StringUtils.getInstance().colorize("&cPlayer not online: " + player));
}
}
/**
* Player info.
*
* @param user
* the user
* @return the string[]
*/
public String[] playerInfo(User user) {
ArrayList<String> msg = new ArrayList<String>();
// title
msg.add("&cPlayer '" + user.getPlayerName() + "' Info");
// last vote
msg.addAll(ArrayUtils.getInstance().convert(voteCommandLast(user)));
// next vote
msg.addAll(ArrayUtils.getInstance().convert(voteCommandNext(user)));
// total
msg.addAll(ArrayUtils.getInstance().convert(voteCommandTotal(user)));
msg = ArrayUtils.getInstance().colorize(msg);
return ArrayUtils.getInstance().convert(msg);
}
/**
* Send top voter monthly score board.
*
* @param player
* the player
* @param page
* the page
*/
public void sendTopVoterAllTimeScoreBoard(final Player player, int page) {
if (AdvancedCoreHook.getInstance().isSendScoreboards()) {
int pagesize = Config.getInstance().getFormatPageSize();
ArrayList<User> users = plugin.convertSet(plugin.topVoterAllTime.keySet());
int pageSize = (users.size() / pagesize);
if ((users.size() % pagesize) != 0) {
pageSize++;
}
String title = StringUtils.getInstance().colorize(config.getFormatCommandVoteTopTitle()
.replace("%page%", "" + page).replace("%maxpages%", "" + pageSize).replace("%Top%", "All"));
SimpleScoreboard scoreboard = new SimpleScoreboard(title);
for (int i = (page - 1) * pagesize; (i < users.size()) && (i < (((page - 1) * pagesize) + 10)); i++) {
scoreboard.add("" + (i + 1) + ": " + users.get(i).getPlayerName(),
plugin.topVoterAllTime.get(users.get(i)));
}
scoreboard.build();
scoreboard.send(player);
Bukkit.getScheduler().runTaskLater(plugin, new Runnable() {
@Override
public void run() {
player.setScoreboard(Bukkit.getScoreboardManager().getNewScoreboard());
}
}, 90);
}
}
/**
* Send top voter daily score board.
*
* @param player
* the player
* @param page
* the page
*/
public void sendTopVoterDailyScoreBoard(final Player player, int page) {
if (AdvancedCoreHook.getInstance().isSendScoreboards()) {
int pagesize = Config.getInstance().getFormatPageSize();
ArrayList<User> users = plugin.convertSet(plugin.topVoterDaily.keySet());
int pageSize = (users.size() / pagesize);
if ((users.size() % pagesize) != 0) {
pageSize++;
}
String title = StringUtils.getInstance().colorize(config.getFormatCommandVoteTopTitle()
.replace("%page%", "" + page).replace("%maxpages%", "" + pageSize).replace("%Top%", "Daily"));
SimpleScoreboard scoreboard = new SimpleScoreboard(title);
for (int i = (page - 1) * pagesize; (i < users.size()) && (i < (((page - 1) * pagesize) + 10)); i++) {
scoreboard.add("" + (i + 1) + ": " + users.get(i).getPlayerName(),
plugin.topVoterDaily.get(users.get(i)));
}
scoreboard.build();
scoreboard.send(player);
Bukkit.getScheduler().runTaskLater(plugin, new Runnable() {
@Override
public void run() {
player.setScoreboard(Bukkit.getScoreboardManager().getNewScoreboard());
}
}, 90);
}
}
/**
* Send top voter monthly score board.
*
* @param player
* the player
* @param page
* the page
*/
public void sendTopVoterMonthlyScoreBoard(final Player player, int page) {
if (AdvancedCoreHook.getInstance().isSendScoreboards()) {
int pagesize = Config.getInstance().getFormatPageSize();
ArrayList<User> users = plugin.convertSet(plugin.topVoterMonthly.keySet());
int pageSize = (users.size() / pagesize);
if ((users.size() % pagesize) != 0) {
pageSize++;
}
String title = StringUtils.getInstance().colorize(config.getFormatCommandVoteTopTitle()
.replace("%page%", "" + page).replace("%maxpages%", "" + pageSize).replace("%Top%", "Monthly"));
SimpleScoreboard scoreboard = new SimpleScoreboard(title);
for (int i = (page - 1) * pagesize; (i < users.size()) && (i < (((page - 1) * pagesize) + 10)); i++) {
scoreboard.add("" + (i + 1) + ": " + users.get(i).getPlayerName(),
plugin.topVoterMonthly.get(users.get(i)));
}
scoreboard.build();
scoreboard.send(player);
Bukkit.getScheduler().runTaskLater(plugin, new Runnable() {
@Override
public void run() {
player.setScoreboard(Bukkit.getScoreboardManager().getNewScoreboard());
}
}, 90);
}
}
/**
* Send top voter weekly score board.
*
* @param player
* the player
* @param page
* the page
*/
public void sendTopVoterWeeklyScoreBoard(final Player player, int page) {
if (AdvancedCoreHook.getInstance().isSendScoreboards()) {
int pagesize = Config.getInstance().getFormatPageSize();
ArrayList<User> users = plugin.convertSet(plugin.topVoterWeekly.keySet());
int pageSize = (users.size() / pagesize);
if ((users.size() % pagesize) != 0) {
pageSize++;
}
String title = StringUtils.getInstance().colorize(config.getFormatCommandVoteTopTitle()
.replace("%page%", "" + page).replace("%maxpages%", "" + pageSize).replace("%Top%", "Weekly"));
SimpleScoreboard scoreboard = new SimpleScoreboard(title);
for (int i = (page - 1) * pagesize; (i < users.size()) && (i < (((page - 1) * pagesize) + 10)); i++) {
scoreboard.add("" + (i + 1) + ": " + users.get(i).getPlayerName(),
plugin.topVoterWeekly.get(users.get(i)));
}
scoreboard.build();
scoreboard.send(player);
Bukkit.getScheduler().runTaskLater(plugin, new Runnable() {
@Override
public void run() {
player.setScoreboard(Bukkit.getScoreboardManager().getNewScoreboard());
}
}, 90);
}
}
/**
* Send vote today score board.
*
* @param player
* the player
* @param page
* the page
*/
public void sendVoteTodayScoreBoard(final Player player, int page) {
if (AdvancedCoreHook.getInstance().isSendScoreboards()) {
int pagesize = Config.getInstance().getFormatPageSize();
String[] voteToday = voteToday();
int maxPage = voteToday.length / pagesize;
if ((voteToday.length % pagesize) != 0) {
maxPage++;
}
SimpleScoreboard scoreboard = new SimpleScoreboard("&cToday's Votes " + page + "/" + maxPage);
for (int i = pagesize * page; (i < voteToday.length) && (i < ((page + 1) * pagesize)); i++) {
scoreboard.add(voteToday[i], i);
}
scoreboard.build();
scoreboard.send(player);
Bukkit.getScheduler().runTaskLater(plugin, new Runnable() {
@Override
public void run() {
player.setScoreboard(Bukkit.getScoreboardManager().getNewScoreboard());
}
}, 90);
}
}
public String[] streak(CommandSender sender, String name) {
ArrayList<String> msg = new ArrayList<String>();
msg.add(config.getFormatCommandsVoteStreakTitle());
msg.addAll(config.getFormatCommandsVoteStreakLines());
User user = UserManager.getInstance().getVotingPluginUser(name);
HashMap<String, String> placeholders = new HashMap<String, String>();
placeholders.put("DailyStreak", "" + user.getDayVoteStreak());
placeholders.put("WeeklyStreak", "" + user.getWeekVoteStreak());
placeholders.put("MonthlyStreak", "" + user.getMonthVoteStreak());
placeholders.put("BestDailyStreak", "" + user.getBestDayVoteStreak());
placeholders.put("BestWeeklyStreak", "" + user.getBestWeekVoteStreak());
placeholders.put("BestMonthlyStreak", "" + user.getBestMonthVoteStreak());
placeholders.put("player", name);
msg = ArrayUtils.getInstance().replacePlaceHolder(msg, placeholders);
return ArrayUtils.getInstance().convert(ArrayUtils.getInstance().colorize(msg));
}
public void updateVoteToday(ArrayList<User> users) {
plugin.voteToday.clear();
for (User user : users) {
HashMap<VoteSite, LocalDateTime> times = new HashMap<VoteSite, LocalDateTime>();
for (VoteSite voteSite : plugin.getVoteSites()) {
long time = user.getTime(voteSite);
if ((LocalDateTime.now().getDayOfMonth() == MiscUtils.getInstance().getDayFromMili(time))
&& (LocalDateTime.now().getMonthValue() == MiscUtils.getInstance().getMonthFromMili(time))
&& (LocalDateTime.now().getYear() == MiscUtils.getInstance().getYearFromMili(time))) {
times.put(voteSite, LocalDateTime.ofInstant(Instant.ofEpochMilli(time), ZoneId.systemDefault()));
}
}
if (times.keySet().size() > 0) {
plugin.voteToday.put(user, times);
}
}
plugin.debug("Updated VoteToday");
}
/**
* Vote command last.
*
* @param user
* the user
* @return the string[]
*/
public String[] voteCommandLast(User user) {
ArrayList<String> msg = new ArrayList<String>();
String playerName = user.getPlayerName();
msg.add(StringUtils.getInstance().replaceIgnoreCase(config.getFormatCommandsVoteLastTitle(), "%player%",
playerName));
for (VoteSite voteSite : plugin.getVoteSites()) {
msg.add(voteCommandLastLine(user, voteSite));
}
msg = ArrayUtils.getInstance().colorize(msg);
return ArrayUtils.getInstance().convert(msg);
}
/**
* Vote command last date.
*
* @param user
* the user
* @param voteSite
* the vote site
* @return the string
*/
public String voteCommandLastDate(User user, VoteSite voteSite) {
long time = user.getTime(voteSite);
if (time > 0) {
Date date = new Date(time);
String timeString = new SimpleDateFormat(config.getFormatTimeFormat()).format(date);
return timeString;
}
return "";
}
public String voteCommandLastLine(User user, VoteSite voteSite) {
String timeString = voteCommandLastDate(user, voteSite);
return config.getFormatCommandsVoteLastLine().replace("%Month% %Day%, %Year% %Hour%:%Minute% %ampm%", "%time%")
.replace("%time%", timeString).replace("%SiteName%", voteSite.getDisplayName());
}
/**
* Vote command next.
*
* @param user
* the user
* @return the string[]
*/
public String[] voteCommandNext(User user) {
ArrayList<String> msg = new ArrayList<String>();
String playerName = user.getPlayerName();
msg.add(StringUtils.getInstance().colorize(StringUtils.getInstance()
.replaceIgnoreCase(config.getFormatCommandsVoteNextTitle(), "%player%", playerName)));
for (VoteSite voteSite : plugin.getVoteSites()) {
String msgLine = config.getFormatCommandsVoteNextLayout();
msgLine = StringUtils.getInstance().replaceIgnoreCase(msgLine, "%info%",
voteCommandNextInfo(user, voteSite));
msgLine = StringUtils.getInstance().replaceIgnoreCase(msgLine, "%SiteName%", voteSite.getDisplayName());
msg.add(StringUtils.getInstance().colorize(msgLine));
}
return ArrayUtils.getInstance().convert(msg);
}
/**
* Vote command next info.
*
* @param user
* the user
* @param voteSite
* the vote site
* @return the string
*/
public String voteCommandNextInfo(User user, VoteSite voteSite) {
String info = new String();
long time = user.getTime(voteSite);
LocalDateTime now = LocalDateTime.now();
LocalDateTime lastVote = LocalDateTime.ofInstant(Instant.ofEpochMilli(time), ZoneId.systemDefault());
if (!voteSite.isVoteDelayDaily()) {
double votedelay = voteSite.getVoteDelay();
if (votedelay == 0) {
String errorMsg = config.getFormatCommandsVoteNextInfoError();
info = errorMsg;
} else {
LocalDateTime nextvote = lastVote.plusHours((long) votedelay);
if (time == 0 || now.isAfter(nextvote)) {
info = config.getFormatCommandsVoteNextInfoCanVote();
} else {
Duration dur = Duration.between(now, nextvote);
long diffHours = dur.getSeconds() / (60 * 60);
long diffMinutes = dur.getSeconds() / 60 - diffHours * 60;
String timeMsg = config.getFormatCommandsVoteNextInfoTime();
timeMsg = StringUtils.getInstance().replaceIgnoreCase(timeMsg, "%hours%", Long.toString(diffHours));
timeMsg = StringUtils.getInstance().replaceIgnoreCase(timeMsg, "%minutes%",
Long.toString(diffMinutes));
info = timeMsg;
}
}
} else {
if (lastVote.getDayOfYear() == now.getDayOfYear() && lastVote.getYear() == now.getYear()) {
LocalDateTime midnight = LocalDateTime.now().plusDays(1).withHour(0).withMinute(0);
Duration dur = Duration.between(now, midnight);
int diffHours = (int) (dur.getSeconds() / (60 * 60));
long diffMinutes = dur.getSeconds() / 60 - diffHours * 60;
String timeMsg = config.getFormatCommandsVoteNextInfoVoteDelayDaily();
timeMsg = StringUtils.getInstance().replaceIgnoreCase(timeMsg, "%hours%", Integer.toString(diffHours));
timeMsg = StringUtils.getInstance().replaceIgnoreCase(timeMsg, "%minutes%", Long.toString(diffMinutes));
info = timeMsg;
} else {
info = config.getFormatCommandsVoteNextInfoCanVote();
}
}
return info;
}
/**
* Vote command total.
*
* @param user
* the user
* @return the string[]
*/
public String[] voteCommandTotal(User user) {
ArrayList<String> msg = new ArrayList<String>();
int daily = user.getDailyTotal();
int weekly = user.getWeeklyTotal();
int month = user.getMonthTotal();
int all = user.getAllTimeTotal();
for (String s : config.getFormatCommandsVoteTotal()) {
String str = StringUtils.getInstance().replaceIgnoreCase(s, "%DailyTotal%", "" + daily);
str = StringUtils.getInstance().replaceIgnoreCase(str, "%WeeklyTotal%", "" + weekly);
str = StringUtils.getInstance().replaceIgnoreCase(str, "%MonthlyTotal%", "" + month);
str = StringUtils.getInstance().replaceIgnoreCase(str, "%AllTimeTotal%", "" + all);
str = StringUtils.getInstance().replaceIgnoreCase(str, "%player%", user.getPlayerName());
msg.add(str);
}
msg = ArrayUtils.getInstance().colorize(msg);
return ArrayUtils.getInstance().convert(msg);
}
/**
* Vote command total all.
*
* @return the string[]
*/
public String[] voteCommandTotalAll() {
ArrayList<String> msg = new ArrayList<String>();
ArrayList<String> uuids = UserManager.getInstance().getAllUUIDs();
int daily = 0;
int weekly = 0;
int month = 0;
int all = 0;
for (String uuid : uuids) {
User user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
daily += user.getDailyTotal();
weekly += user.getWeeklyTotal();
month += user.getMonthTotal();
all += user.getAllTimeTotal();
}
for (String s : config.getFormatCommandsVoteTotalAll()) {
String str = StringUtils.getInstance().replaceIgnoreCase(s, "%DailyTotal%", "" + daily);
str = StringUtils.getInstance().replaceIgnoreCase(str, "%WeeklyTotal%", "" + weekly);
str = StringUtils.getInstance().replaceIgnoreCase(str, "%MonthlyTotal%", "" + month);
str = StringUtils.getInstance().replaceIgnoreCase(str, "%AllTimeTotal%", "" + all);
msg.add(str);
}
msg = ArrayUtils.getInstance().colorize(msg);
return ArrayUtils.getInstance().convert(msg);
}
/**
* Vote help text.
*
* @param sender
* the sender
* @return the array list
*/
public ArrayList<TextComponent> voteHelpText(CommandSender sender) {
ArrayList<TextComponent> texts = new ArrayList<TextComponent>();
HashMap<String, TextComponent> unsorted = new HashMap<String, TextComponent>();
texts.add(StringUtils.getInstance().stringToComp(config.getFormatCommandsVoteHelpTitle()));
boolean requirePerms = config.getFormatCommandsVoteHelpRequirePermission();
for (CommandHandler cmdHandle : plugin.voteCommand) {
if (cmdHandle.hasPerm(sender)) {
unsorted.put(cmdHandle.getHelpLineCommand("/vote"), cmdHandle.getHelpLine("/vote"));
} else if (!requirePerms) {
unsorted.put(cmdHandle.getHelpLineCommand("/vote"), cmdHandle.getHelpLine("/vote"));
}
}
ArrayList<String> unsortedList = new ArrayList<String>();
unsortedList.addAll(unsorted.keySet());
Collections.sort(unsortedList, String.CASE_INSENSITIVE_ORDER);
for (String cmd : unsortedList) {
texts.add(unsorted.get(cmd));
}
return texts;
}
/**
* Vote today.
*
* @return the string[]
*/
public String[] voteToday() {
ArrayList<String> msg = new ArrayList<String>();
for (User user : plugin.voteToday.keySet()) {
for (VoteSite voteSite : plugin.voteToday.get(user).keySet()) {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(Config.getInstance().getFormatTimeFormat());
String timeString = plugin.voteToday.get(user).get(voteSite).format(formatter);
msg.add("&6" + user.getPlayerName() + " : " + voteSite.getKey() + " : " + timeString);
}
}
msg = ArrayUtils.getInstance().colorize(msg);
return ArrayUtils.getInstance().convert(msg);
}
public String[] voteURLs(User user) {
ArrayList<String> sites = new ArrayList<String>();
List<String> title = config.getFormatCommandsVoteText();
if (title != null) {
sites.addAll(title);
}
if (config.getFormatCommandsVoteAutoInputSites()) {
int counter = 0;
for (VoteSite voteSite : plugin.getVoteSites()) {
counter++;
String voteURL = voteSite.getVoteURL();
String msg = config.getFormatCommandsVoteURLS();
msg = StringUtils.getInstance().colorize(msg);
msg = StringUtils.getInstance().replaceIgnoreCase(msg, "%num%", Integer.toString(counter));
msg = StringUtils.getInstance().replaceIgnoreCase(msg, "%url%", voteURL);
msg = StringUtils.getInstance().replaceIgnoreCase(msg, "%SiteName%", voteSite.getDisplayName());
msg = StringUtils.getInstance().replaceIgnoreCase(msg, "%player%", user.getPlayerName());
msg = StringUtils.getInstance().replacePlaceHolder(msg, "Next",
"" + voteCommandNextInfo(user, voteSite));
sites.add(msg);
}
}
if (user != null) {
HashMap<String, String> phs = new HashMap<String, String>();
phs.put("DailyTotal", "" + user.getDailyTotal());
phs.put("WeekTotal", "" + user.getWeeklyTotal());
phs.put("MonthTotal", "" + user.getMonthTotal());
phs.put("Total", "" + user.getAllTimeTotal());
sites = ArrayUtils.getInstance().replacePlaceHolder(sites, phs);
}
sites = ArrayUtils.getInstance().colorize(sites);
return ArrayUtils.getInstance().convert(sites);
}
}
@@ -1,77 +0,0 @@
package com.Ben12345rocks.VotingPlugin.Commands.Executers;
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import com.Ben12345rocks.AdvancedCore.Objects.CommandHandler;
import com.Ben12345rocks.VotingPlugin.Main;
import com.Ben12345rocks.VotingPlugin.Config.Config;
import com.Ben12345rocks.VotingPlugin.Config.ConfigVoteSites;
// TODO: Auto-generated Javadoc
/**
* The Class CommandAdminVote.
*/
public class CommandAdminVote implements CommandExecutor {
/** The instance. */
private static CommandAdminVote instance = new CommandAdminVote();
/**
* Gets the single instance of CommandAdminVote.
*
* @return single instance of CommandAdminVote
*/
public static CommandAdminVote getInstance() {
return instance;
}
/** The config. */
Config config = Config.getInstance();
/** The plugin. */
private Main plugin = Main.plugin;
/** The vote sites. */
ConfigVoteSites voteSites = ConfigVoteSites.getInstance();
/**
* Instantiates a new command admin vote.
*/
private CommandAdminVote() {
}
/**
* Instantiates a new command admin vote.
*
* @param plugin
* the plugin
*/
public CommandAdminVote(Main plugin) {
this.plugin = plugin;
}
/*
* (non-Javadoc)
*
* @see org.bukkit.command.CommandExecutor#onCommand(org.bukkit.command.
* CommandSender , org.bukkit.command.Command, java.lang.String,
* java.lang.String[])
*/
@Override
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
for (CommandHandler commandHandler : plugin.adminVoteCommand) {
if (commandHandler.runCommand(sender, args)) {
return true;
}
}
// invalid command
sender.sendMessage(ChatColor.RED + "No valid arguments, see /adminvote help!");
return true;
}
}
@@ -1,306 +0,0 @@
package com.Ben12345rocks.VotingPlugin.Commands.GUI;
import java.util.ArrayList;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.ClickType;
import org.bukkit.inventory.ItemStack;
import com.Ben12345rocks.AdvancedCore.Util.Inventory.BInventory;
import com.Ben12345rocks.AdvancedCore.Util.Inventory.BInventory.ClickEvent;
import com.Ben12345rocks.AdvancedCore.Util.Inventory.BInventoryButton;
import com.Ben12345rocks.AdvancedCore.Util.Misc.ArrayUtils;
import com.Ben12345rocks.AdvancedCore.Util.Misc.PlayerUtils;
import com.Ben12345rocks.AdvancedCore.Util.ValueRequest.InputMethod;
import com.Ben12345rocks.AdvancedCore.Util.ValueRequest.ValueRequest;
import com.Ben12345rocks.AdvancedCore.Util.ValueRequest.ValueRequestBuilder;
import com.Ben12345rocks.AdvancedCore.Util.ValueRequest.Listeners.BooleanListener;
import com.Ben12345rocks.AdvancedCore.Util.ValueRequest.Listeners.NumberListener;
import com.Ben12345rocks.AdvancedCore.Util.ValueRequest.Listeners.StringListener;
import com.Ben12345rocks.VotingPlugin.Main;
import com.Ben12345rocks.VotingPlugin.Config.ConfigVoteSites;
import com.Ben12345rocks.VotingPlugin.Events.VotiferEvent;
import com.Ben12345rocks.VotingPlugin.Objects.VoteSite;
public class AdminGUI {
static AdminGUI instance = new AdminGUI();
/**
* Gets the single instance of Commands.
*
* @return single instance of Commands
*/
public static AdminGUI getInstance() {
return instance;
}
/** The plugin. */
Main plugin = Main.plugin;
/**
* Instantiates a new commands.
*/
private AdminGUI() {
}
/**
* Open admin GUI.
*
* @return ArrayList of buttons
*/
public ArrayList<BInventoryButton> adminGUIButtons() {
ArrayList<BInventoryButton> buttons = new ArrayList<BInventoryButton>();
ArrayList<String> lore = new ArrayList<String>();
lore.add("&cOnly enabled sites are listed in this section");
lore.add("&cMiddle Click to create");
buttons.add(new BInventoryButton("&cVoteSites", ArrayUtils.getInstance().convert(lore),
new ItemStack(Material.STONE)) {
@Override
public void onClick(ClickEvent event) {
if (event.getWhoClicked() instanceof Player) {
Player player = event.getWhoClicked();
if (event.getClick().equals(ClickType.MIDDLE)) {
new ValueRequest().requestString(player, new StringListener() {
@Override
public void onInput(Player player, String value) {
ConfigVoteSites.getInstance().generateVoteSite(value);
player.sendMessage("Generated site");
plugin.reload();
}
});
} else {
openAdminGUIVoteSites(player);
}
}
}
});
lore = new ArrayList<String>();
buttons.add(new BInventoryButton("&cReload Plugin", ArrayUtils.getInstance().convert(lore),
new ItemStack(Material.STONE, 1, (short) 3)) {
@Override
public void onClick(ClickEvent event) {
event.getPlayer().performCommand("av reload");
}
});
return buttons;
}
public void loadHook() {
for (BInventoryButton b : adminGUIButtons()) {
com.Ben12345rocks.AdvancedCore.Commands.GUI.AdminGUI.getInstance().addButton(b);
}
}
/**
* Open admin GUI vote sites.
*
* @param player
* the player
*/
public void openAdminGUIVoteSites(Player player) {
BInventory inv = new BInventory("VoteSites");
int count = 0;
for (VoteSite voteSite : plugin.getVoteSites()) {
ArrayList<String> lore = new ArrayList<String>();
lore.add("Priority: " + voteSite.getPriority());
lore.add("Name: " + voteSite.getDisplayName());
lore.add("ServiceSite: " + voteSite.getServiceSite());
lore.add("VoteURL: " + voteSite.getVoteURL());
lore.add("VoteDelay: " + voteSite.getVoteDelay());
// lore.add("Rewards: " +
// ArrayUtils.getInstance().makeStringList(voteSite.getRewards()));
inv.addButton(count, new BInventoryButton(voteSite.getKey(), ArrayUtils.getInstance().convert(lore),
new ItemStack(Material.STONE)) {
@Override
public void onClick(ClickEvent event) {
Player player = event.getWhoClicked();
openAdminGUIVoteSiteSite(player, voteSite);
}
});
count++;
}
inv.openInventory(player);
}
/**
* Open admin GUI vote site site.
*
* @param player
* the player
* @param voteSite
* the vote site
*/
public void openAdminGUIVoteSiteSite(Player player, VoteSite voteSite) {
BInventory inv = new BInventory("VoteSite: " + voteSite.getDisplayName());
inv.setMeta(player, "VoteSite", voteSite);
inv.addButton(new BInventoryButton(voteSite.getItem().setName("&cForce vote")) {
@Override
public void onClick(ClickEvent event) {
ArrayList<String> playerNames = new ArrayList<String>();
for (Player p : Bukkit.getOnlinePlayers()) {
playerNames.add(p.getName());
}
new ValueRequestBuilder(new StringListener() {
@Override
public void onInput(Player player, String value) {
Object ob = PlayerUtils.getInstance().getPlayerMeta(player, "VoteSite");
if (ob != null) {
VoteSite site = (VoteSite) ob;
VotiferEvent.playerVote(value, site.getServiceSite(), false);
}
}
}, ArrayUtils.getInstance().convert(playerNames)).usingMethod(InputMethod.INVENTORY)
.allowCustomOption(true).request(event.getWhoClicked());
}
});
inv.addButton(new BInventoryButton("SetPriority", new String[0], new ItemStack(Material.STONE)) {
@Override
public void onClick(ClickEvent event) {
Player player = event.getWhoClicked();
new ValueRequest().requestNumber(player, "" + voteSite.getPriority(), null, new NumberListener() {
@Override
public void onInput(Player player, Number value) {
VoteSite voteSite = (VoteSite) event.getMeta("VoteSite");
ConfigVoteSites.getInstance().setPriority(voteSite.getKey(), value.intValue());
player.sendMessage("Set Priority");
plugin.reload();
}
});
}
});
inv.addButton(new BInventoryButton("SetServiceSite", new String[0], new ItemStack(Material.STONE)) {
@Override
public void onClick(ClickEvent event) {
if (event.getWhoClicked() instanceof Player) {
Player player = event.getWhoClicked();
new ValueRequest().requestString(player, voteSite.getServiceSite(), null, new StringListener() {
@Override
public void onInput(Player player, String value) {
VoteSite voteSite = (VoteSite) event.getMeta("VoteSite");
String siteName = voteSite.getKey();
ConfigVoteSites.getInstance().setServiceSite(siteName, value);
player.sendMessage("Set ServiceSite");
plugin.reload();
}
});
}
}
});
inv.addButton(new BInventoryButton("SetName", new String[0], new ItemStack(Material.STONE)) {
@Override
public void onClick(ClickEvent event) {
if (event.getWhoClicked() instanceof Player) {
Player player = event.getWhoClicked();
new ValueRequest().requestString(player, voteSite.getServiceSite(), null, new StringListener() {
@Override
public void onInput(Player player, String value) {
VoteSite voteSite = (VoteSite) event.getMeta("VoteSite");
ConfigVoteSites.getInstance().setDisplayName(voteSite.getKey(), value);
player.sendMessage("Set name");
plugin.reload();
}
});
}
}
});
inv.addButton(new BInventoryButton("SetVoteURL", new String[0], new ItemStack(Material.STONE)) {
@Override
public void onClick(ClickEvent event) {
if (event.getWhoClicked() instanceof Player) {
Player player = event.getWhoClicked();
new ValueRequest().requestString(player, voteSite.getVoteURL(), null, new StringListener() {
@Override
public void onInput(Player player, String value) {
VoteSite voteSite = (VoteSite) event.getMeta("VoteSite");
String siteName = voteSite.getKey();
ConfigVoteSites.getInstance().setVoteURL(siteName, value);
player.sendMessage("Set VoteURL");
plugin.reload();
}
});
}
}
});
inv.addButton(new BInventoryButton("SetVoteDelay", new String[0], new ItemStack(Material.STONE)) {
@Override
public void onClick(ClickEvent event) {
Player player = event.getWhoClicked();
new ValueRequest().requestNumber(player, "" + voteSite.getVoteDelay(), null, new NumberListener() {
@Override
public void onInput(Player player, Number value) {
VoteSite voteSite = (VoteSite) event.getMeta("VoteSite");
String siteName = voteSite.getKey();
ConfigVoteSites.getInstance().setVoteDelay(siteName, value.intValue());
player.sendMessage("Set VoteDelay");
plugin.reload();
}
});
}
});
inv.addButton(inv.getNextSlot(),
new BInventoryButton("SetEnabled", new String[0], new ItemStack(Material.STONE)) {
@Override
public void onClick(ClickEvent event) {
Player player = event.getWhoClicked();
new ValueRequest().requestBoolean(player,
"" + ConfigVoteSites.getInstance().getVoteSiteEnabled(voteSite.getKey()),
new BooleanListener() {
@Override
public void onInput(Player player, boolean value) {
VoteSite voteSite = (VoteSite) event.getMeta("VoteSite");
String siteName = voteSite.getKey();
ConfigVoteSites.getInstance().setEnabled(siteName, value);
player.sendMessage("Set Enabled");
plugin.reload();
}
});
}
});
inv.openInventory(player);
}
}
@@ -1,691 +0,0 @@
package com.Ben12345rocks.VotingPlugin.Commands.GUI;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.ClickType;
import com.Ben12345rocks.AdvancedCore.AdvancedCoreHook;
import com.Ben12345rocks.AdvancedCore.Util.Inventory.BInventory;
import com.Ben12345rocks.AdvancedCore.Util.Inventory.BInventory.ClickEvent;
import com.Ben12345rocks.AdvancedCore.Util.Inventory.BInventoryButton;
import com.Ben12345rocks.AdvancedCore.Util.Item.ItemBuilder;
import com.Ben12345rocks.AdvancedCore.Util.Misc.ArrayUtils;
import com.Ben12345rocks.AdvancedCore.Util.Misc.MiscUtils;
import com.Ben12345rocks.AdvancedCore.Util.Misc.PlayerUtils;
import com.Ben12345rocks.AdvancedCore.Util.Misc.StringUtils;
import com.Ben12345rocks.VotingPlugin.Main;
import com.Ben12345rocks.VotingPlugin.Commands.Commands;
import com.Ben12345rocks.VotingPlugin.Config.Config;
import com.Ben12345rocks.VotingPlugin.Objects.TopVoter;
import com.Ben12345rocks.VotingPlugin.Objects.User;
import com.Ben12345rocks.VotingPlugin.Objects.VoteSite;
import com.Ben12345rocks.VotingPlugin.TopVoter.TopVoterHandler;
import com.Ben12345rocks.VotingPlugin.UserManager.UserManager;
import com.Ben12345rocks.VotingPlugin.VoteShop.VoteShop;
public class PlayerGUIs {
static PlayerGUIs instance = new PlayerGUIs();
/**
* Gets the single instance of Commands.
*
* @return single instance of Commands
*/
public static PlayerGUIs getInstance() {
return instance;
}
/** The plugin. */
Main plugin = Main.plugin;
/**
* Instantiates a new commands.
*/
private PlayerGUIs() {
}
public ItemBuilder getBackButton() {
ConfigurationSection sec = Config.getInstance().getBackButton();
if (sec != null) {
return new ItemBuilder(sec);
}
return new ItemBuilder(Material.PAPER, 1).setName("&8Back to VoteGUI");
}
public User getSelectedPlayer(Player player) {
User str = (User) PlayerUtils.getInstance().getPlayerMeta(player, "SelectedPlayerGUIs");
return str;
}
public void openVoteBest(Player player, User user) {
setSelectedPlayer(player, user);
BInventory inv = new BInventory(StringUtils.getInstance()
.replacePlaceHolder(Config.getInstance().getGUIVoteBestName(), "player", user.getPlayerName()));
inv.addButton(new BInventoryButton(new ItemBuilder(Config.getInstance().getGUIVoteBestDayBestItem())
.addPlaceholder("Best", "" + user.getBestDayVoteStreak())) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(Config.getInstance().getGUIVoteBestWeekBestItem())
.addPlaceholder("Best", "" + user.getBestWeekVoteStreak())) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(Config.getInstance().getGUIVoteBestMonthBestItem())
.addPlaceholder("Best", "" + user.getBestMonthVoteStreak())) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
inv.openInventory(player);
}
public void openVoteGUI(Player player, User user) {
if (user == null) {
user = UserManager.getInstance().getVotingPluginUser(player);
setSelectedPlayer(player, user);
}
if ((!player.getName().equals(user.getPlayerName())
&& !player.hasPermission("VotingPlugin.Commands.Vote.GUI.Other")
&& !player.hasPermission("VotingPlugin.Mod"))
|| (!player.hasPermission("VotingPlugin.Commands.Vote.GUI")
&& !player.hasPermission("VotingPlugin.Player"))) {
player.sendMessage(StringUtils.getInstance().colorize(AdvancedCoreHook.getInstance().getFormatNoPerms()));
return;
}
setSelectedPlayer(player, user);
BInventory inv = new BInventory(StringUtils.getInstance()
.replacePlaceHolder(Config.getInstance().getGUIVoteGUIName(), "player", user.getPlayerName()));
for (String slot : Config.getInstance().getVoteGUISlots()) {
ItemBuilder builder = new ItemBuilder(Config.getInstance().getVoteGUISlotSection(slot));
String[] lore = new String[1];
lore = ArrayUtils.getInstance().convert(Config.getInstance().getVoteGUISlotLore(slot));
if (lore.length == 0) {
if (slot.equalsIgnoreCase("url")) {
lore = Commands.getInstance().voteURLs(user);
} else if (slot.equalsIgnoreCase("next")) {
lore = Commands.getInstance().voteCommandNext(user);
} else if (slot.equalsIgnoreCase("last")) {
lore = Commands.getInstance().voteCommandLast(user);
} else if (slot.equalsIgnoreCase("total")) {
lore = Commands.getInstance().voteCommandTotal(user);
} else if (slot.equalsIgnoreCase("top")) {
String str = Config.getInstance().getVoteTopDefault();
if (str.equalsIgnoreCase("monthly")) {
lore = TopVoterHandler.getInstance().topVoterMonthly(1);
} else if (str.equalsIgnoreCase("weekly")) {
lore = TopVoterHandler.getInstance().topVoterWeekly(1);
} else if (str.equalsIgnoreCase("daily")) {
lore = TopVoterHandler.getInstance().topVoterDaily(1);
} else {
lore = TopVoterHandler.getInstance().topVoterAllTime(1);
}
} else if (slot.equalsIgnoreCase("today")) {
lore = Commands.getInstance().voteToday();
} else if (slot.equalsIgnoreCase("help")) {
lore = new String[] { "Click to view help" };
}
}
HashMap<String, String> placeholders = new HashMap<String, String>();
placeholders.put("points", "" + user.getPoints());
builder.setPlaceholders(placeholders);
builder.setLore(ArrayUtils.getInstance().convert(lore));
inv.addButton(Config.getInstance().getVoteGUISlotSlot(slot), new BInventoryButton(builder) {
@Override
public void onClick(ClickEvent event) {
Player player = event.getWhoClicked();
String cmd = Config.getInstance().getVoteGUISlotCommand(slot);
User user = getSelectedPlayer(player);
if (!cmd.equals("")) {
player.performCommand(cmd);
} else {
if (slot.equalsIgnoreCase("url")) {
openVoteURL(player);
} else if (slot.equalsIgnoreCase("next")) {
openVoteNext(player, user);
} else if (slot.equalsIgnoreCase("last")) {
openVoteLast(player, user);
} else if (slot.equalsIgnoreCase("total")) {
openVoteTotal(player, user);
} else if (slot.equalsIgnoreCase("top")) {
openVoteTop(player, null);
} else if (slot.equalsIgnoreCase("today")) {
openVoteToday(player);
} else if (slot.equalsIgnoreCase("help")) {
player.performCommand("vote help");
} else if (slot.equalsIgnoreCase("shop")) {
VoteShop.getInstance().voteShop(player);
}
}
}
});
}
inv.openInventory(player);
}
public void openVoteLast(Player player, User user) {
setSelectedPlayer(player, user);
BInventory inv = new BInventory(StringUtils.getInstance()
.replacePlaceHolder(Config.getInstance().getGUIVoteLastName(), "player", user.getPlayerName()));
for (VoteSite site : plugin.getVoteSites()) {
inv.addButton(inv.getNextSlot(), new BInventoryButton(site.getItem().setName(site.getDisplayName())
.setLore(Commands.getInstance().voteCommandLastLine(user, site)).setAmountNone(1)) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
}
if (Config.getInstance().getGUIVoteLastBackButton()) {
inv.addButton(new BInventoryButton(getBackButton()) {
@Override
public void onClick(ClickEvent event) {
openVoteGUI(event.getPlayer(), getSelectedPlayer(event.getPlayer()));
}
});
}
inv.openInventory(player);
}
public void openVoteNext(Player player, User user) {
setSelectedPlayer(player, user);
BInventory inv = new BInventory(StringUtils.getInstance()
.replacePlaceHolder(Config.getInstance().getGUIVoteNextName(), "player", user.getPlayerName()));
for (VoteSite site : plugin.getVoteSites()) {
inv.addButton(inv.getNextSlot(), new BInventoryButton(site.getItem().setName(site.getDisplayName())
.setLore(Commands.getInstance().voteCommandNextInfo(user, site)).setAmountNone(1)) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
}
if (Config.getInstance().getGUIVoteNextBackButton()) {
inv.addButton(new BInventoryButton(getBackButton()) {
@Override
public void onClick(ClickEvent event) {
openVoteGUI(event.getPlayer(), getSelectedPlayer(event.getPlayer()));
}
});
}
inv.openInventory(player);
}
public void openVoteStreak(Player player, User user) {
setSelectedPlayer(player, user);
BInventory inv = new BInventory(StringUtils.getInstance()
.replacePlaceHolder(Config.getInstance().getGUIVoteStreakName(), "player", user.getPlayerName()));
inv.addButton(new BInventoryButton(new ItemBuilder(Config.getInstance().getGUIVoteStreakCurrentDayStreakItem())
.addPlaceholder("Streak", "" + user.getDayVoteStreak())) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(Config.getInstance().getGUIVoteStreakCurrentWeekStreakItem())
.addPlaceholder("Streak", "" + user.getWeekVoteStreak())) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
inv.addButton(
new BInventoryButton(new ItemBuilder(Config.getInstance().getGUIVoteStreakCurrentMonthStreakItem())
.addPlaceholder("Streak", "" + user.getMonthVoteStreak())) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(Config.getInstance().getGUIVoteStreakHighestDayStreakItem())
.addPlaceholder("Streak", "" + user.getBestDayVoteStreak())) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(Config.getInstance().getGUIVoteStreakHighestWeekStreakItem())
.addPlaceholder("Streak", "" + user.getBestWeekVoteStreak())) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
inv.addButton(
new BInventoryButton(new ItemBuilder(Config.getInstance().getGUIVoteStreakHighestMonthStreakItem())
.addPlaceholder("Streak", "" + user.getBestMonthVoteStreak())) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
if (Config.getInstance().getGUIVoteStreakBackButton()) {
inv.addButton(new BInventoryButton(getBackButton()) {
@Override
public void onClick(ClickEvent event) {
openVoteGUI(event.getPlayer(), getSelectedPlayer(event.getPlayer()));
}
});
}
inv.openInventory(player);
}
public void openVoteToday(Player player) {
setSelectedPlayer(player, null);
BInventory inv = new BInventory(Config.getInstance().getGUIVoteTodayName());
for (User user : plugin.voteToday.keySet()) {
for (VoteSite voteSite : plugin.voteToday.get(user).keySet()) {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(Config.getInstance().getFormatTimeFormat());
String timeString = plugin.voteToday.get(user).get(voteSite).format(formatter);
String msg = "&6" + user.getPlayerName() + " : " + voteSite.getDisplayName() + " : " + timeString;
inv.addButton(inv.getNextSlot(), new BInventoryButton(user.getPlayerName(), new String[] { msg },
MiscUtils.getInstance().setSkullOwner(user.getOfflinePlayer())) {
@Override
public void onClick(ClickEvent clickEvent) {
User user = UserManager.getInstance()
.getVotingPluginUser(clickEvent.getClickedItem().getItemMeta().getDisplayName());
openVoteGUI(player, user);
}
});
}
}
if (Config.getInstance().getGUIVoteTodayBackButton()) {
inv.addButton(new BInventoryButton(getBackButton()) {
@Override
public void onClick(ClickEvent event) {
openVoteGUI(event.getPlayer(), getSelectedPlayer(event.getPlayer()));
}
});
}
inv.openInventory(player);
}
public void openVoteTop(Player player, TopVoter top) {
if (top == null) {
top = TopVoter.getDefault();
}
BInventory inv = null;
Set<Entry<User, Integer>> users = null;
String topVoter = "";
if (top.equals(TopVoter.Monthly)) {
topVoter = Config.getInstance().getFormatTopVoterMonthly();
users = plugin.topVoterMonthly.entrySet();
} else if (top.equals(TopVoter.Weekly)) {
topVoter = Config.getInstance().getFormatTopVoterWeekly();
users = plugin.topVoterWeekly.entrySet();
} else if (top.equals(TopVoter.Daily)) {
topVoter = Config.getInstance().getFormatTopVoterDaily();
users = plugin.topVoterDaily.entrySet();
} else {
topVoter = Config.getInstance().getFormatTopVoterAllTime();
users = plugin.topVoterAllTime.entrySet();
}
inv = new BInventory(StringUtils.getInstance().replacePlaceHolder(Config.getInstance().getGUIVoteTopName(),
"topvoter", topVoter));
int pos = 1;
for (Entry<User, Integer> entry : users) {
inv.addButton(new BInventoryButton(
new ItemBuilder(MiscUtils.getInstance().setSkullOwner(entry.getKey().getOfflinePlayer()))
.setName(Config.getInstance().getGUIVoteTopItemName())
.addLoreLine(Config.getInstance().getGUIVoteTopItemLore())
.addPlaceholder("position", "" + pos)
.addPlaceholder("player", entry.getKey().getPlayerName())
.addPlaceholder("votes", "" + entry.getValue())) {
@Override
public void onClick(ClickEvent clickEvent) {
// ItemBuilder item = new ItemBuilder(clickEvent.getClickedItem());
// String name = ChatColor.stripColor(item.getName()).split(":")[1].trim();
String name = (String) clickEvent.getButton().getData("player");
User user = UserManager.getInstance().getVotingPluginUser(name);
openVoteGUI(player, user);
}
}.addData("player", entry.getKey().getPlayerName()));
pos++;
}
final TopVoter cur = top;
inv.getPageButtons().add(new BInventoryButton(
new ItemBuilder(Config.getInstance().getGUIVoteTopSwitchItem()).addPlaceholder("Top", topVoter)) {
@Override
public void onClick(ClickEvent clickEvent) {
if (!clickEvent.getClick().equals(ClickType.RIGHT)) {
openVoteTop(player, cur.next());
} else {
openVoteTop(player, cur.prev());
}
}
});
if (Config.getInstance().getGUIVoteTopBackButton()) {
inv.getPageButtons().add(new BInventoryButton(getBackButton().setSlot(1)) {
@Override
public void onClick(ClickEvent event) {
openVoteGUI(event.getPlayer(), getSelectedPlayer(event.getPlayer()));
}
});
}
inv.setPages(true);
inv.setMaxInvSize(Config.getInstance().getGUIVoteTopSize());
inv.openInventory(player);
}
public void openVoteTotal(Player player, User user) {
setSelectedPlayer(player, user);
BInventory inv = new BInventory(StringUtils.getInstance()
.replacePlaceHolder(Config.getInstance().getGUIVoteTotalName(), "player", user.getPlayerName()));
inv.addButton(new BInventoryButton(new ItemBuilder(Config.getInstance().getGUIVoteTotalDayTotalItem())
.addPlaceholder("Total", "" + user.getDailyTotal())) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(Config.getInstance().getGUIVoteTotalWeekTotalItem())
.addPlaceholder("Total", "" + user.getWeeklyTotal())) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(Config.getInstance().getGUIVoteTotalMonthTotalItem())
.addPlaceholder("Total", "" + user.getMonthTotal())) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(Config.getInstance().getGUIVoteTotalAllTimeTotalItem())
.addPlaceholder("Total", "" + user.getAllTimeTotal())) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
if (Config.getInstance().getGUIVoteTotalBackButton()) {
inv.addButton(new BInventoryButton(getBackButton()) {
@Override
public void onClick(ClickEvent event) {
openVoteGUI(event.getPlayer(), getSelectedPlayer(event.getPlayer()));
}
});
}
inv.openInventory(player);
}
/**
* Vote URL.
*
* @param player
* the player
*/
public void openVoteURL(Player player) {
setSelectedPlayer(player, null);
BInventory inv = new BInventory(Config.getInstance().getGUIVoteURLName());
User user = UserManager.getInstance().getVotingPluginUser(player);
int count = 0;
if (Config.getInstance().getVoteURLViewAllUrlsButtonEnabled()) {
ItemBuilder builderAll = new ItemBuilder(
Config.getInstance().getVoteURLAlreadyVotedAllUrlsButtonItemSection());
if (user.canVoteAll()) {
builderAll = new ItemBuilder(Config.getInstance().getVoteURLCanVoteAllUrlsButtonItemSection());
}
if (!builderAll.hasCustomDisplayName()) {
builderAll.setName("&4All Voting Sites");
}
if (!builderAll.hasCustomLore()) {
builderAll.setLore("&cClick Me");
}
inv.addButton(count, new BInventoryButton(builderAll) {
@Override
public void onClick(ClickEvent event) {
User user = UserManager.getInstance().getVotingPluginUser(event.getPlayer());
Player player = event.getWhoClicked();
player.closeInventory();
user.sendMessage(Commands.getInstance().voteURLs(user));
}
});
count++;
}
for (final VoteSite voteSite : plugin.getVoteSites()) {
ItemBuilder builder = new ItemBuilder(Config.getInstance().getVoteURLAlreadyVotedItemSection());
if (user.canVoteSite(voteSite)) {
builder = new ItemBuilder(Config.getInstance().getVoteURLCanVoteItemSection());
} else {
builder.addLoreLine(Config.getInstance().getVoteURLNextVote().replace("%Info%",
Commands.getInstance().voteCommandNextInfo(user, voteSite)));
}
builder.setName(Config.getInstance().getVoteURLSiteName().replace("%Name%", voteSite.getDisplayName()));
inv.addButton(count, new BInventoryButton(builder) {
@Override
public void onClick(ClickEvent event) {
Player player = event.getWhoClicked();
if (player != null) {
player.closeInventory();
if (Config.getInstance().commandsVoteRewardFromVoteURL
&& event.getClick().equals(ClickType.RIGHT)) {
voteReward(player, voteSite.getKey());
} else {
User user = UserManager.getInstance().getVotingPluginUser(player);
user.sendMessage(StringUtils.getInstance().replacePlaceHolder(StringUtils.getInstance()
.replacePlaceHolder(StringUtils.getInstance().replacePlaceHolder(
Config.getInstance().getGUIVoteURLURLText(), "voteurl",
voteSite.getVoteURL()), "sitename", voteSite.getDisplayName()),
"player", player.getName()));
}
}
}
});
count++;
}
if (Config.getInstance().getGUIVoteURLBackButton()) {
inv.addButton(new BInventoryButton(getBackButton()) {
@Override
public void onClick(ClickEvent event) {
openVoteGUI(event.getPlayer(), getSelectedPlayer(event.getPlayer()));
}
});
}
inv.openInventory(player);
}
public void openVoteURL(Player player, String voteSite) {
User user = UserManager.getInstance().getVotingPluginUser(player);
VoteSite site = plugin.getVoteSite(voteSite);
BInventory inv = new BInventory(StringUtils.getInstance()
.replacePlaceHolder(Config.getInstance().getGUIVoteURLSiteName(), "site", site.getDisplayName()));
inv.setMeta(player, "VoteSite", site);
inv.addButton(
new BInventoryButton(new ItemBuilder(Material.BOW).setName("&4URL").addLoreLine("Click to see URL")) {
@Override
public void onClick(ClickEvent clickEvent) {
VoteSite site = (VoteSite) clickEvent.getMeta("VoteSite");
clickEvent.getWhoClicked().sendMessage(site.getVoteURL());
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(Material.COMPASS).setName("&4Next Vote")
.addLoreLine(Commands.getInstance().voteCommandNextInfo(user, site))) {
@Override
public void onClick(ClickEvent clickEvent) {
openVoteURL(clickEvent.getPlayer());
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(Material.WATCH).setName("&4Last Vote")
.addLoreLine(Commands.getInstance().voteCommandLastLine(user, site))) {
@Override
public void onClick(ClickEvent clickEvent) {
openVoteURL(clickEvent.getPlayer());
}
});
if (Config.getInstance().getGUIVoteURLBackButton()) {
inv.addButton(new BInventoryButton(getBackButton()) {
@Override
public void onClick(ClickEvent event) {
openVoteGUI(event.getPlayer(), getSelectedPlayer(event.getPlayer()));
}
});
}
inv.openInventory(player);
}
public void setSelectedPlayer(Player player, User user) {
PlayerUtils.getInstance().setPlayerMeta(player, "SelectedPlayerGUIs", user);
}
/**
* Vote reward.
*
* @param player
* the player
* @param siteName
* the site name
*/
public void voteReward(Player player, String siteName) {
BInventory inv = new BInventory(Config.getInstance().getGUIVoteRewardName());
if ((siteName == null) || (siteName == "")) {
int count = 0;
for (VoteSite voteSite : plugin.getVoteSites()) {
try {
ItemBuilder builder = voteSite.getItem();
final VoteSite site = voteSite;
inv.addButton(count, new BInventoryButton(builder) {
@Override
public void onClick(ClickEvent event) {
Player player = event.getWhoClicked();
if (player != null) {
player.closeInventory();
Bukkit.getScheduler().runTask(plugin, new Runnable() {
@Override
public void run() {
player.performCommand("vote reward " + site.getKey());
}
});
}
}
});
count++;
} catch (Exception ex) {
}
}
} else {
for (String itemName : Config.getInstance().getVoteSiteItems(siteName)) {
ItemBuilder builder = new ItemBuilder(Config.getInstance().getVoteSiteItemsSection(siteName, itemName));
inv.addButton(Config.getInstance().getVoteSiteItemsSlot(siteName, itemName),
new BInventoryButton(builder) {
@Override
public void onClick(ClickEvent event) {
Player player = event.getWhoClicked();
if (player != null) {
player.closeInventory();
}
}
});
}
}
inv.openInventory(player);
}
}
File diff suppressed because it is too large. Load diff
@@ -1,58 +0,0 @@
package com.Ben12345rocks.VotingPlugin.Events;
import org.bukkit.block.Sign;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.block.Action;
import org.bukkit.event.player.PlayerInteractEvent;
import com.Ben12345rocks.VotingPlugin.Main;
import com.Ben12345rocks.VotingPlugin.Objects.SignHandler;
import com.Ben12345rocks.VotingPlugin.UserManager.UserManager;
// TODO: Auto-generated Javadoc
/**
* The Class PlayerInteract.
*/
public class PlayerInteract implements Listener {
/** The plugin. */
private static Main plugin;
/**
* Instantiates a new player interact.
*
* @param plugin
* the plugin
*/
public PlayerInteract(Main plugin) {
PlayerInteract.plugin = plugin;
}
/**
* On player interact.
*
* @param event
* the event
*/
@EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
public void onPlayerInteract(PlayerInteractEvent event) {
Player player = event.getPlayer();
if (event.getAction() == Action.RIGHT_CLICK_BLOCK) {
// plugin.debug("Checking for sign click");
if (event.getClickedBlock().getState() instanceof Sign) {
// plugin.debug(player.getName() + " right clicked a sign");
for (SignHandler sign : plugin.signs) {
if (sign.isLocationSame(event.getClickedBlock().getLocation())) {
// plugin.debug(player.getName() +
// " right clicked a top voter sign, sending message");
UserManager.getInstance().getVotingPluginUser(player).sendMessage(sign.getRightClickMessage());
}
}
}
}
}
}
@@ -1,74 +0,0 @@
package com.Ben12345rocks.VotingPlugin.Events;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerLoginEvent;
import com.Ben12345rocks.AdvancedCore.AdvancedCoreHook;
import com.Ben12345rocks.AdvancedCore.Objects.UserStorage;
import com.Ben12345rocks.VotingPlugin.Main;
import com.Ben12345rocks.VotingPlugin.Objects.User;
import com.Ben12345rocks.VotingPlugin.UserManager.UserManager;
// TODO: Auto-generated Javadoc
/**
* The Class PlayerJoinEvent.
*/
public class PlayerJoinEvent implements Listener {
/** The plugin. */
private static Main plugin;
/**
* Instantiates a new player join event.
*
* @param plugin
* the plugin
*/
public PlayerJoinEvent(Main plugin) {
PlayerJoinEvent.plugin = plugin;
}
/**
* On player login.
*
* @param event
* the event
*/
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onPlayerLogin(PlayerLoginEvent event) {
plugin.getServer().getScheduler().runTaskLaterAsynchronously(plugin, new Runnable() {
@Override
public void run() {
if (event.getPlayer() == null
|| (AdvancedCoreHook.getInstance().getStorageType().equals(UserStorage.MYSQL)
&& AdvancedCoreHook.getInstance().getMysql() == null)) {
return;
}
Player player = event.getPlayer();
if (player != null) {
User user = UserManager.getInstance().getVotingPluginUser(player);
// run remind
user.loginMessage();
if (user.getData().hasData()) {
// give offline vote (if they voted
// offline)
user.offVote();
}
}
}
}, 20L);
}
}
@@ -1,80 +0,0 @@
package com.Ben12345rocks.VotingPlugin.Events;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import com.Ben12345rocks.VotingPlugin.Objects.User;
// TODO: Auto-generated Javadoc
/**
* The Class PlayerVoteEvent.
*/
public class PlayerVoteAllSitesEvent extends Event {
/** The Constant handlers. */
private static final HandlerList handlers = new HandlerList();
/**
* Gets the handler list.
*
* @return the handler list
*/
public static HandlerList getHandlerList() {
return handlers;
}
private User user;
/** The cancelled. */
private boolean cancelled;
public PlayerVoteAllSitesEvent(User user) {
super();
setUser(user);
}
/*
* (non-Javadoc)
*
* @see org.bukkit.event.Event#getHandlers()
*/
@Override
public HandlerList getHandlers() {
return handlers;
}
/**
* @return the user
*/
public User getUser() {
return user;
}
/**
* Checks if is cancelled.
*
* @return true, if is cancelled
*/
public boolean isCancelled() {
return cancelled;
}
/**
* Sets the cancelled.
*
* @param bln
* the new cancelled
*/
public void setCancelled(boolean bln) {
cancelled = bln;
}
/**
* @param user
* the user to set
*/
public void setUser(User user) {
this.user = user;
}
}
@@ -1,102 +0,0 @@
package com.Ben12345rocks.VotingPlugin.Events;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import com.Ben12345rocks.VotingPlugin.Objects.VoteSite;
// TODO: Auto-generated Javadoc
/**
* The Class PlayerVoteEvent.
*/
public class PlayerVoteEvent extends Event {
/** The Constant handlers. */
private static final HandlerList handlers = new HandlerList();
/**
* Gets the handler list.
*
* @return the handler list
*/
public static HandlerList getHandlerList() {
return handlers;
}
/** The player. */
private String player;
/** The vote site. */
private VoteSite voteSite;
/** The cancelled. */
private boolean cancelled;
public PlayerVoteEvent(VoteSite voteSite, String voteUsername) {
super();
setPlayer(voteUsername);
setVoteSite(voteSite);
}
/*
* (non-Javadoc)
*
* @see org.bukkit.event.Event#getHandlers()
*/
@Override
public HandlerList getHandlers() {
return handlers;
}
/**
* Gets the player.
*
* @return the player
*/
public String getPlayer() {
return player;
}
/**
* Gets the vote site.
*
* @return the vote site
*/
public VoteSite getVoteSite() {
return voteSite;
}
/**
* Checks if is cancelled.
*
* @return true, if is cancelled
*/
public boolean isCancelled() {
return cancelled;
}
/**
* Sets the cancelled.
*
* @param bln
* the new cancelled
*/
public void setCancelled(boolean bln) {
cancelled = bln;
}
public void setPlayer(String voteUsername) {
this.player = voteUsername;
}
/**
* Sets the vote site.
*
* @param voteSite
* the new vote site
*/
public void setVoteSite(VoteSite voteSite) {
this.voteSite = voteSite;
}
}
@@ -1,205 +0,0 @@
package com.Ben12345rocks.VotingPlugin.Events;
import java.util.ArrayList;
import org.bukkit.Bukkit;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import com.Ben12345rocks.AdvancedCore.AdvancedCoreHook;
import com.Ben12345rocks.AdvancedCore.Objects.UserStorage;
import com.Ben12345rocks.AdvancedCore.Util.Misc.ArrayUtils;
import com.Ben12345rocks.AdvancedCore.Util.Misc.PlayerUtils;
import com.Ben12345rocks.VotingPlugin.Main;
import com.Ben12345rocks.VotingPlugin.Config.Config;
import com.Ben12345rocks.VotingPlugin.Config.ConfigVoteSites;
import com.Ben12345rocks.VotingPlugin.Data.ServerData;
import com.Ben12345rocks.VotingPlugin.Objects.User;
import com.Ben12345rocks.VotingPlugin.Objects.VoteSite;
import com.Ben12345rocks.VotingPlugin.OtherRewards.OtherVoteReward;
import com.Ben12345rocks.VotingPlugin.UserManager.UserManager;
import com.Ben12345rocks.VotingPlugin.VoteParty.VoteParty;
import com.vexsoftware.votifier.model.Vote;
import com.vexsoftware.votifier.model.VotifierEvent;
// TODO: Auto-generated Javadoc
/**
* The Class VotiferEvent.
*/
public class VotiferEvent implements Listener {
/** The config. */
static Config config = Config.getInstance();
/** The config vote sites. */
static ConfigVoteSites configVoteSites = ConfigVoteSites.getInstance();
/** The plugin. */
static Main plugin = Main.plugin;
private static Object object = new Object();
public static void playerVote(final String playerName, final String voteSiteURL) {
playerVote(playerName, voteSiteURL, true);
}
public static void playerVote(final String playerName, final String voteSiteURL, final boolean realVote) {
if (!config.allowUnJoined() && !PlayerUtils.getInstance().isValidUser(playerName)) {
plugin.getLogger().warning("Player " + playerName
+ " has not joined before, disregarding vote, set AllowUnjoined to true to prevent this");
return;
}
User user = UserManager.getInstance().getVotingPluginUser(playerName);
VoteSite voteSite = plugin.getVoteSite(voteSiteURL);
if (voteSite == null) {
if (!Config.getInstance().getDisableNoServiceSiteMessage()) {
plugin.getLogger().warning("No voting site with the service site: '" + voteSiteURL + "'");
plugin.getLogger().warning(
"Please read here on how to fix it: https://github.com/Ben12345rocks/VotingPlugin/wiki/Common-Problems");
ArrayList<String> services = new ArrayList<String>();
for (VoteSite site : plugin.getVoteSites()) {
services.add(site.getServiceSite());
}
plugin.getLogger()
.warning("Current known service sites: " + ArrayUtils.getInstance().makeStringList(services));
}
return;
}
synchronized (object) {
// vote party
VoteParty.getInstance().vote(user, realVote);
// broadcast vote if enabled in config
if (config.getBroadCastVotesEnabled()) {
if (!Config.getInstance().getFormatBroadcastWhenOnline() || user.isOnline()) {
voteSite.broadcastVote(user);
}
}
// update last vote time
user.setTime(voteSite);
OtherVoteReward.getInstance().checkFirstVote(user);
if (user.isReminded()) {
user.setReminded(false);
}
// check if player has voted on all sites in one day
if (user.isOnline() || voteSite.isGiveOffline()) {
user.playerVote(voteSite, true, false);
user.closeInv();
} else {
user.addOfflineVote(voteSite.getKey());
// plugin.debug(ArrayUtils.getInstance().makeStringList(user.getOfflineVotes()));
plugin.debug(
"Offline vote set for " + playerName + " (" + user.getUUID() + ") on " + voteSite.getKey());
}
// add to total votes
if (Config.getInstance().getCountFakeVotes() || realVote) {
if (Config.getInstance().getAddTotals()) {
user.addTotal();
user.addTotalDaily();
user.addTotalWeekly();
}
user.addPoints();
}
OtherVoteReward.getInstance().checkAllSites(user);
OtherVoteReward.getInstance().checkCumualativeVotes(user);
OtherVoteReward.getInstance().checkMilestone(user);
if (Config.getInstance().getClearCacheOnVote()) {
if (AdvancedCoreHook.getInstance().getStorageType().equals(UserStorage.MYSQL)) {
AdvancedCoreHook.getInstance().getMysql().removePlayer(user.getUUID());
}
}
}
plugin.setUpdate(true);
}
/**
* Instantiates a new votifer event.
*
* @param plugin
* the plugin
*/
public VotiferEvent(Main plugin) {
VotiferEvent.plugin = plugin;
}
/**
* On votifer event.
*
* @param event
* the event
*/
@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
public void onVotiferEvent(VotifierEvent event) {
Vote vote = event.getVote();
final String voteSite = vote.getServiceName();
final String voteUsername = vote.getUsername().trim();
Bukkit.getScheduler().runTaskAsynchronously(plugin, new Runnable() {
@Override
public void run() {
ServerData.getInstance().addServiceSite(voteSite);
}
});
if (voteUsername.length() == 0) {
plugin.getLogger().warning("No name from vote on " + voteSite);
return;
}
plugin.getLogger().info("Recieved a vote from '" + voteSite + "' by player '" + voteUsername + "'!");
plugin.debug("PlayerUsername: " + voteUsername);
plugin.debug("VoteSite: " + voteSite);
Bukkit.getScheduler().runTaskAsynchronously(plugin, new Runnable() {
@Override
public void run() {
String voteSiteName = plugin.getVoteSiteName(voteSite);
ArrayList<String> sites = configVoteSites.getVoteSitesNames();
if (sites != null) {
if (!sites.contains(voteSiteName) && Config.getInstance().getAutoCreateVoteSites()) {
plugin.getLogger()
.warning("VoteSite " + voteSiteName + " doe not exist, generaterating one...");
ConfigVoteSites.getInstance().generateVoteSite(voteSiteName);
}
} else if (Config.getInstance().getAutoCreateVoteSites()) {
plugin.getLogger().warning("VoteSite " + voteSiteName + " doe not exist, generaterating one...");
ConfigVoteSites.getInstance().generateVoteSite(voteSiteName);
}
PlayerVoteEvent voteEvent = new PlayerVoteEvent(plugin.getVoteSite(voteSiteName), voteUsername);
plugin.getServer().getPluginManager().callEvent(voteEvent);
if (voteEvent.isCancelled()) {
plugin.debug("Vote cancelled");
return;
}
playerVote(voteUsername, voteSite, true);
}
});
}
}
File diff suppressed because it is too large. Load diff
@@ -1,78 +0,0 @@
package com.Ben12345rocks.VotingPlugin.Objects;
import java.util.ArrayList;
import com.Ben12345rocks.VotingPlugin.Config.Config;
public enum TopVoter {
AllTime, Monthly, Weekly, Daily;
public static TopVoter getDefault() {
TopVoter top = getTopVoter(Config.getInstance().getVoteTopDefault());
if (top != null) {
return top;
}
return AllTime;
}
public static TopVoter getTopVoter(String str) {
for (TopVoter value : values()) {
if (value.toString().equalsIgnoreCase(str)) {
return value;
}
}
return AllTime;
}
public TopVoter next() {
ArrayList<TopVoter> list = new ArrayList<TopVoter>();
if (Config.getInstance().getLoadTopVoterAllTime()) {
list.add(TopVoter.AllTime);
}
if (Config.getInstance().getLoadTopVoterMonthly()) {
list.add(TopVoter.Monthly);
}
if (Config.getInstance().getLoadTopVoterWeekly()) {
list.add(TopVoter.Weekly);
}
if (Config.getInstance().getLoadTopVoterDaily()) {
list.add(TopVoter.Daily);
}
for (int i = 0; i < list.size(); i++) {
if (list.get(i).equals(this)) {
int next = i + 1;
if (next > list.size() - 1) {
next = 0;
}
return TopVoter.values()[next];
}
}
return TopVoter.AllTime;
}
public TopVoter prev() {
ArrayList<TopVoter> list = new ArrayList<TopVoter>();
if (Config.getInstance().getLoadTopVoterAllTime()) {
list.add(TopVoter.AllTime);
}
if (Config.getInstance().getLoadTopVoterMonthly()) {
list.add(TopVoter.Monthly);
}
if (Config.getInstance().getLoadTopVoterWeekly()) {
list.add(TopVoter.Weekly);
}
if (Config.getInstance().getLoadTopVoterDaily()) {
list.add(TopVoter.Daily);
}
for (int i = list.size()-1; i >= 0; i--) {
if (list.get(i).equals(this)) {
int prev = i - 1;
if (prev < 0) {
prev = list.size()-1;
}
return TopVoter.values()[prev];
}
}
return TopVoter.AllTime;
}
}
@@ -1,760 +1,30 @@
package com.Ben12345rocks.VotingPlugin.Objects;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Collectors;
import org.bukkit.entity.Player;
import com.Ben12345rocks.AdvancedCore.AdvancedCoreHook;
import com.Ben12345rocks.AdvancedCore.Objects.RewardBuilder;
import com.Ben12345rocks.AdvancedCore.Objects.RewardHandler;
import com.Ben12345rocks.AdvancedCore.Objects.UUID;
import com.Ben12345rocks.AdvancedCore.Util.Misc.MiscUtils;
import com.Ben12345rocks.AdvancedCore.Util.Misc.StringUtils;
import com.Ben12345rocks.VotingPlugin.Main;
import com.Ben12345rocks.VotingPlugin.Config.Config;
import com.Ben12345rocks.VotingPlugin.Config.ConfigVoteSites;
import com.Ben12345rocks.VotingPlugin.OtherRewards.OtherVoteReward;
import com.Ben12345rocks.VotingPlugin.VoteParty.VoteParty;
import com.Ben12345rocks.VotingPlugin.VoteReminding.VoteReminding;
// TODO: Auto-generated Javadoc
/**
* The Class User.
*/
public class User extends com.Ben12345rocks.AdvancedCore.Objects.User {
/** The plugin. */
static Main plugin = Main.plugin;
/**
* Instantiates a new user.
*
* @param player
* the player
*/
@Deprecated
public User(Player player) {
super(plugin, player);
}
/**
* Instantiates a new user.
*
* @param playerName
* the player name
*/
@Deprecated
public User(String playerName) {
super(plugin, playerName);
}
/**
* Instantiates a new user.
*
* @param uuid
* the uuid
*/
@Deprecated
public User(UUID uuid) {
super(plugin, uuid);
}
/**
* Instantiates a new user.
*
* @param uuid
* the uuid
* @param loadName
* the load name
*/
@Deprecated
public User(UUID uuid, boolean loadName) {
super(plugin, uuid, loadName);
}
public void addAllTimeTotal() {
setAllTimeTotal(getAllTimeTotal() + 1);
}
public void addDayVoteStreak() {
setDayVoteStreak(getDayVoteStreak() + 1);
}
public void addMonthTotal() {
setMonthTotal(getMonthTotal() + 1);
}
public void addMonthVoteStreak() {
setMonthVoteStreak(getMonthVoteStreak() + 1);
}
public void addOfflineOtherReward(String reward) {
ArrayList<String> offlineOtherRewards = getOfflineOtherRewards();
offlineOtherRewards.add(reward);
setOfflineOtherRewards(offlineOtherRewards);
}
public void addOfflineVote(String voteSiteName) {
ArrayList<String> offlineVotes = getOfflineVotes();
offlineVotes.add(voteSiteName);
setOfflineVotes(offlineVotes);
}
/**
* Adds the points.
*/
public void addPoints() {
int points = Config.getInstance().getPointsOnVote();
if (points != 0) {
addPoints(points);
}
}
/**
* Adds the points.
*
* @param value
* the value
*/
public void addPoints(int value) {
setPoints(getPoints() + value);
}
/**
* Adds the total.
*
*/
public void addTotal() {
setMilestoneCount(getMilestoneCount() + 1);
addMonthTotal();
addAllTimeTotal();
}
/**
* Adds the total daily.
*
*
*/
public void addTotalDaily() {
setDailyTotal(getDailyTotal() + 1);
}
/**
* Adds the total weekly.
*
*
*/
public void addTotalWeekly() {
setWeeklyTotal(getWeeklyTotal() + 1);
}
public void addWeekVoteStreak() {
setWeekVoteStreak(getWeekVoteStreak() + 1);
}
/**
* Can vote all.
*
* @return true, if successful
*/
public boolean canVoteAll() {
for (VoteSite voteSite : plugin.getVoteSites()) {
boolean canVote = canVoteSite(voteSite);
if (!canVote) {
return false;
}
}
return true;
}
public boolean getDisableBroadcast() {
return getUserData().getBoolean("DisableBroadcast");
}
public void setDisableBroadcast(boolean value) {
getUserData().setBoolean("DisableBroadcast", value);
}
/**
* Can vote site.
*
* @param voteSite
* the vote site
* @return true, if successful
*/
public boolean canVoteSite(VoteSite voteSite) {
String siteName = voteSite.getKey();
long time = getTime(voteSite);
if (time == 0) {
return true;
}
LocalDateTime now = LocalDateTime.now();
LocalDateTime lastVote = LocalDateTime.ofInstant(Instant.ofEpochMilli(time), ZoneId.systemDefault());
if (!voteSite.isVoteDelayDaily()) {
int votedelay = ConfigVoteSites.getInstance().getVoteDelay(siteName);
if (votedelay == 0) {
return false;
}
LocalDateTime nextvote = lastVote.plusHours(votedelay);
return now.isAfter(nextvote);
} else {
if (now.getDayOfYear() != lastVote.getDayOfYear() || now.getYear() != lastVote.getYear()) {
return true;
}
return false;
}
}
/**
* Check all votes.
*
* @return true, if successful
*/
public boolean checkAllVotes() {
User user = this;
ArrayList<Integer> months = new ArrayList<Integer>();
ArrayList<Integer> days = new ArrayList<Integer>();
for (VoteSite voteSite : plugin.getVoteSites()) {
long time = user.getTime(voteSite);
if (time != 0) {
months.add(MiscUtils.getInstance().getMonthFromMili(time));
days.add(MiscUtils.getInstance().getDayFromMili(time));
} else {
return false;
}
}
// check months
for (int i = 0; i < months.size(); i++) {
if (!months.get(0).equals(months.get(i))) {
return false;
}
}
// check days
for (int i = 0; i < days.size(); i++) {
if (!days.get(0).equals(days.get(i))) {
return false;
}
}
return true;
}
public void clearOfflineRewards() {
setOfflineVotes(new ArrayList<String>());
setOfflineRewards(new ArrayList<String>());
setOfflineOtherRewards(new ArrayList<String>());
}
public void clearTotals() {
setAllTimeTotal(0);
resetDailyTotalVotes();
resetMonthlyTotalVotes();
setWeeklyTotal(0);
}
public int getAllTimeTotal() {
return getUserData().getInt("AllTimeTotal");
}
public int getBestDayVoteStreak() {
return getData().getInt("BestDayVoteStreak");
}
public int getBestMonthVoteStreak() {
return getData().getInt("BestMonthVoteStreak");
}
public int getBestWeekVoteStreak() {
return getData().getInt("BestWeekVoteStreak");
}
public int getDailyTotal() {
return getUserData().getInt("DailyTotal");
}
public int getDayVoteStreak() {
return getData().getInt("DayVoteStreak");
}
public HashMap<String, Boolean> getHasGottenMilestone() {
HashMap<String, Boolean> hasGottenMilestone = new HashMap<String, Boolean>();
ArrayList<String> milestoneList = getUserData().getStringList("GottenMileStones");
for (String str : milestoneList) {
String[] data = str.split("//");
if (data.length > 1) {
boolean gotten = Boolean.parseBoolean(data[1]);
hasGottenMilestone.put(data[0], gotten);
}
}
return hasGottenMilestone;
}
public int getHighestDailyTotal() {
return getData().getInt("HighestDailyTotal");
}
public int getHighestMonthlyTotal() {
return getData().getInt("HighestMonthlyTotal");
}
public int getHighestWeeklyTotal() {
return getData().getInt("HighestWeeklyTotal");
}
public int getLastMonthTotal() {
return getData().getInt("LastMonthTotal");
}
public HashMap<VoteSite, Long> getLastVotes() {
HashMap<VoteSite, Long> lastVotes = new HashMap<VoteSite, Long>();
ArrayList<String> LastVotesList = getUserData().getStringList("LastVotes");
for (String str : LastVotesList) {
String[] data = str.split("//");
if (data.length > 1 && plugin.hasVoteSite(data[0])) {
VoteSite site = plugin.getVoteSite(data[0]);
if (site != null) {
long time = 0;
try {
time = Long.parseLong(data[1]);
} catch (NumberFormatException e) {
time = 0;
plugin.debug("Not long: " + data[1]);
}
lastVotes.put(site, time);
}
}
}
return lastVotes;
}
/**
* Gets the last vote times sorted.
*
* @return the last vote times sorted
*/
public HashMap<VoteSite, Long> getLastVoteTimesSorted() {
LinkedHashMap<VoteSite, Long> times = new LinkedHashMap<VoteSite, Long>();
for (VoteSite voteSite : plugin.getVoteSites()) {
times.put(voteSite, getTime(voteSite));
}
LinkedHashMap<VoteSite, Long> sorted = (LinkedHashMap<VoteSite, Long>) times.entrySet().stream()
.sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
return sorted;
}
public int getMilestoneCount() {
return getData().getInt("MilestoneCount", getAllTimeTotal());
}
public int getMonthTotal() {
return getData().getInt("MonthTotal");
}
public int getMonthVoteStreak() {
return getData().getInt("MonthVoteStreak");
}
public ArrayList<String> getOfflineOtherRewards() {
return getUserData().getStringList("OfflineOtherRewards");
}
public ArrayList<String> getOfflineVotes() {
return getUserData().getStringList("OfflineVotes");
}
/**
* Gets the points.
*
* @return the points
*/
public int getPoints() {
return getUserData().getInt("Points");
}
/**
* Gets the time.
*
* @param voteSite
* the vote site
* @return the time
*/
public long getTime(VoteSite voteSite) {
HashMap<VoteSite, Long> lastVotes = getLastVotes();
if (lastVotes.containsKey(voteSite)) {
return lastVotes.get(voteSite);
}
return 0;
}
public int getVotePartyVotes() {
return getUserData().getInt("VotePartyVotes");
}
public int getWeeklyTotal() {
return getUserData().getInt("WeeklyTotal");
}
public int getWeekVoteStreak() {
return getData().getInt("WeekVoteStreak");
}
public void giveDailyTopVoterAward(int place, String path) {
new RewardBuilder(Config.getInstance().getData(), Config.getInstance().getDailyAwardRewardsPath(path))
.withPlaceHolder("place", "" + place).withPlaceHolder("topvoter", "Daily").send(this);
}
public void giveMonthlyTopVoterAward(int place, String path) {
new RewardBuilder(Config.getInstance().getData(), Config.getInstance().getMonthlyAwardRewardsPath(path))
.withPlaceHolder("place", "" + place).withPlaceHolder("topvoter", "Monthly").send(this);
}
public void giveOfflineOtherRewards() {
ArrayList<String> offlineRewards = getOfflineOtherRewards();
for (String str : offlineRewards) {
if (str.equalsIgnoreCase("FirstVote")) {
OtherVoteReward.getInstance().giveFirstVoteRewards(this, false);
} else if (str.equalsIgnoreCase("AllSites")) {
OtherVoteReward.getInstance().giveAllSitesRewards(this, false);
} else if (str.equalsIgnoreCase("VoteParty")) {
VoteParty.getInstance().giveReward(this);
} else if (str.contains("Cumulative")) {
String st = str.substring("Cumulative".length());
if (StringUtils.getInstance().isInt(st)) {
int votesRequired = Integer.parseInt(st);
if (votesRequired != 0) {
if (Config.getInstance().getCumulativeRewardEnabled(votesRequired)) {
OtherVoteReward.getInstance().giveCumulativeVoteReward(this, false, votesRequired);
}
}
}
} else if (str.contains("MileStone")) {
String st = str.substring("MileStone".length());
if (StringUtils.getInstance().isInt(st)) {
int votesRequired = Integer.parseInt(st);
if (votesRequired > 0) {
if (Config.getInstance().getMilestoneRewardEnabled(votesRequired)) {
OtherVoteReward.getInstance().giveMilestoneVoteReward(this, true, votesRequired);
}
}
}
} else if (str.contains("VoteStreak")) {
String[] args = str.split("_");
if (args.length > 2) {
String type = args[1];
String st = args[2];
if (Config.getInstance().getVoteStreakRewardEnabled(type, st)) {
OtherVoteReward.getInstance().giveVoteStreakReward(this, false, type, "" + st, -1);
}
}
} else {
plugin.debug("Reward handle for " + str + " does not exist!");
}
}
if (!offlineRewards.isEmpty()) {
setOfflineOtherRewards(new ArrayList<String>());
}
}
public void giveWeeklyTopVoterAward(int place, String path) {
new RewardBuilder(Config.getInstance().getData(), Config.getInstance().getWeeklyAwardRewardsPath(path))
.withPlaceHolder("place", "" + place).withPlaceHolder("topvoter", "Weekly").send(this);
}
/**
* Checks for gotten first vote.
*
* @return true if user got the first vote reward
*/
public boolean hasGottenFirstVote() {
return getAllTimeTotal() != 0;
}
/**
* Checks for gotten milestone.
*
* @param votesRequired
* the votes required
* @return true, if successful
*/
public boolean hasGottenMilestone(int votesRequired) {
HashMap<String, Boolean> hasGottenMilestone = getHasGottenMilestone();
if (hasGottenMilestone.containsKey("" + votesRequired)) {
return hasGottenMilestone.get("" + votesRequired);
}
return false;
}
public boolean isReminded() {
return Boolean.valueOf(getUserData().getString("Reminded"));
}
public boolean isTopVoterIgnore() {
return Boolean.valueOf(getUserData().getString("TopVoterIgnore"));
}
/**
* Login message.
*/
public void loginMessage() {
if (Config.getInstance().getVoteRemindingRemindOnLogin()) {
VoteReminding.getInstance().runRemindLogin(this);
}
}
/**
* Off vote.
*/
public void offVote() {
AdvancedCoreHook.getInstance().extraDebug("Checking offline vote site votes");
Player player = getPlayer();
if (player != null) {
boolean topVoterIngorePerm = player.hasPermission("VotingPlugin.TopVoter.Ignore");
if (isTopVoterIgnore() != topVoterIngorePerm) {
setTopVoterIgnore(topVoterIngorePerm);
}
ArrayList<String> offlineVotes = getOfflineVotes();
// plugin.debug(ArrayUtils.getInstance().makeStringList(offlineVotes));
if (offlineVotes.size() > 0) {
sendVoteEffects(true);
}
for (int i = 0; i < offlineVotes.size(); i++) {
if (plugin.hasVoteSite(offlineVotes.get(i))) {
plugin.debug("Giving offline site reward: " + offlineVotes.get(i));
playerVote(plugin.getVoteSite(offlineVotes.get(i)), false, true);
} else {
plugin.debug("Site doesn't exist: " + offlineVotes.get(i));
}
}
setOfflineVotes(new ArrayList<String>());
giveOfflineOtherRewards();
}
}
/**
* Player vote.
*
* @param voteSite
* the vote site
* @param online
* the online
* @param broadcast
* the broadcast
*/
public void playerVote(VoteSite voteSite, boolean online, boolean broadcast) {
if (Config.getInstance().getFormatBroadcastWhenOnline() && Config.getInstance().getBroadCastVotesEnabled()
&& broadcast) {
voteSite.broadcastVote(this);
}
voteSite.giveSiteReward(this, online);
}
/**
* Removes the points.
*
* @param points
* the points
* @return true, if successful
*/
public boolean removePoints(int points) {
if (getPoints() >= points) {
setPoints(getPoints() - points);
return true;
}
return false;
}
public void resetDailyTotalVotes() {
setDailyTotal(0);
}
public void resetMonthlyTotalVotes() {
setLastMonthTotal(getMonthTotal());
setMonthTotal(0);
}
public void resetWeeklyTotalVotes() {
setWeeklyTotal(0);
}
/**
* Send vote effects.
*
* @param online
* the online
*/
public void sendVoteEffects(boolean online) {
RewardHandler.getInstance().giveReward(this, Config.getInstance().getData(),
Config.getInstance().getAnySiteRewardsPath(), online);
}
public void setAllTimeTotal(int allTimeTotal) {
getUserData().setInt("AllTimeTotal", allTimeTotal);
}
public void setBestDayVoteStreak(int streak) {
getData().setInt("BestDayVoteStreak", streak);
}
public void setBestMonthVoteStreak(int streak) {
getData().setInt("BestMonthVoteStreak", streak);
}
public void setBestWeekVoteStreak(int streak) {
getData().setInt("BestWeekVoteStreak", streak);
}
public void setDailyTotal(int total) {
getUserData().setInt("DailyTotal", total);
}
public void setDayVoteStreak(int streak) {
getData().setInt("DayVoteStreak", streak);
if (getBestDayVoteStreak() < streak) {
setBestDayVoteStreak(streak);
}
}
public void setHasGotteMilestone(int votesRequired, boolean b) {
HashMap<String, Boolean> hasGottenMilestone = getHasGottenMilestone();
hasGottenMilestone.put("" + votesRequired, b);
setHasGottenMilestone(hasGottenMilestone);
}
public void setHasGottenMilestone(HashMap<String, Boolean> hasGottenMilestone) {
ArrayList<String> data = new ArrayList<String>();
for (Entry<String, Boolean> entry : hasGottenMilestone.entrySet()) {
String str = entry.getKey() + "//" + entry.getValue().booleanValue();
data.add(str);
}
getUserData().setStringList("GottenMileStones", data);
}
public void setHighestDailyTotal(int total) {
getData().setInt("HighestDailyTotal", total);
}
public void setHighestMonthlyTotal(int total) {
getData().setInt("HighestMonthlyTotal", total);
}
public void setHighestWeeklyTotal(int total) {
getData().setInt("HighestWeeklyTotal", total);
}
public void setLastMonthTotal(int total) {
getData().setInt("LastMonthTotal", total);
}
public void setLastVotes(HashMap<VoteSite, Long> lastVotes) {
ArrayList<String> data = new ArrayList<String>();
for (Entry<VoteSite, Long> entry : lastVotes.entrySet()) {
String str = entry.getKey().getKey() + "//" + entry.getValue().longValue();
data.add(str);
}
getUserData().setStringList("LastVotes", data);
}
public void setMilestoneCount(int value) {
getData().setInt("MilestoneCount", value);
}
public void setMonthTotal(int total) {
getData().setInt("MonthTotal", total);
}
public void setMonthVoteStreak(int streak) {
getData().setInt("MonthVoteStreak", streak);
if (getBestMonthVoteStreak() < streak) {
setBestMonthVoteStreak(streak);
}
}
public void setOfflineOtherRewards(ArrayList<String> offlineOtherRewards) {
getUserData().setStringList("OfflineOtherRewards", offlineOtherRewards);
}
public void setOfflineVotes(ArrayList<String> offlineVotes) {
getUserData().setStringList("OfflineVotes", offlineVotes);
}
/**
* Sets the points.
*
* @param value
* the new points
*/
public void setPoints(int value) {
getUserData().setInt("Points", value);
}
public void setReminded(boolean reminded) {
getUserData().setString("Reminded", "" + reminded);
}
public void setTime(VoteSite voteSite) {
setTime(voteSite, LocalDateTime.now().atZone(ZoneId.systemDefault()).toInstant().toEpochMilli());
}
public void setTime(VoteSite voteSite, Long time) {
HashMap<VoteSite, Long> lastVotes = getLastVotes();
lastVotes.put(voteSite, time);
setLastVotes(lastVotes);
}
public void setTopVoterIgnore(boolean topVoterIgnore) {
getUserData().setString("TopVoterIgnore", "" + topVoterIgnore);
}
public void setVotePartyVotes(int value) {
getUserData().setInt("VotePartyVotes", value);
}
public void setWeeklyTotal(int total) {
getUserData().setInt("WeeklyTotal", total);
}
public void setWeekVoteStreak(int streak) {
getData().setInt("WeekVoteStreak", streak);
if (getBestWeekVoteStreak() < streak) {
setBestWeekVoteStreak(streak);
}
}
public boolean shouldBeReminded() {
Player player = getPlayer();
if (player != null) {
if (player.hasPermission("VotingPlugin.NoRemind")) {
return false;
}
}
return true;
}
}
package com.Ben12345rocks.VotingPlugin.Objects;
import org.bukkit.entity.Player;
import com.bencodez.votingplugin.user.UserManager;
import com.bencodez.votingplugin.user.VotingPluginUser;
@Deprecated
public class User {
private VotingPluginUser user;
public User(Player p) {
user = UserManager.getInstance().getVotingPluginUser(p);
}
public int getPoints() {
return user.getPoints();
}
public void setPoints(int points) {
user.setPoints(points);
}
public void addPoints(int points) {
user.addPoints(points);
}
public boolean removePoints(int points) {
return user.removePoints(points);
}
}
@@ -1,336 +0,0 @@
package com.Ben12345rocks.VotingPlugin.Objects;
import java.util.ArrayList;
import java.util.HashMap;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.Player;
import com.Ben12345rocks.AdvancedCore.Objects.RewardBuilder;
import com.Ben12345rocks.AdvancedCore.Objects.RewardHandler;
import com.Ben12345rocks.AdvancedCore.Util.Item.ItemBuilder;
import com.Ben12345rocks.AdvancedCore.Util.Misc.MiscUtils;
import com.Ben12345rocks.AdvancedCore.Util.Misc.StringUtils;
import com.Ben12345rocks.VotingPlugin.Main;
import com.Ben12345rocks.VotingPlugin.Config.Config;
import com.Ben12345rocks.VotingPlugin.Config.ConfigVoteSites;
import com.Ben12345rocks.VotingPlugin.UserManager.UserManager;
/**
* The Class VoteSite.
*/
public class VoteSite {
/** The config. */
static Config config = Config.getInstance();
/** The config vote sites. */
static ConfigVoteSites configVoteSites = ConfigVoteSites.getInstance();
/** The plugin. */
static Main plugin = Main.plugin;
/** The vote URL. */
private String voteURL;
/** The service site. */
private String serviceSite;
/** The site name. */
private String key;
private String displayName;
/** The vote delay. */
private double voteDelay;
/** The enabled. */
private boolean enabled;
private boolean voteDelayDaily;
/** The priority. */
private int priority;
private ConfigurationSection item;
private boolean giveOffline;
/**
* Instantiates a new vote site.
*
* @param plugin
* the plugin
*/
public VoteSite(Main plugin) {
VoteSite.plugin = plugin;
}
/**
* Instantiates a new vote site.
*
* @param siteName
* the site name
*/
public VoteSite(String siteName) {
key = siteName.replace(".", "_");
init();
}
/**
* Broadcast vote.
*
* @param user
* the user
*/
public void broadcastVote(User user) {
if (!user.isVanished()) {
String playerName = user.getPlayerName();
String bc = StringUtils.getInstance().colorize(config.getFormatBroadCastMsg());
HashMap<String, String> placeholders = new HashMap<String, String>();
placeholders.put("player", playerName);
placeholders.put("nickname", user.getPlayer().getDisplayName());
placeholders.put("sitename", getDisplayName());
bc = StringUtils.getInstance().replacePlaceHolder(bc, placeholders);
ArrayList<Player> players = new ArrayList<Player>();
for (Player p : Bukkit.getOnlinePlayers()) {
if (!UserManager.getInstance().getVotingPluginUser(p).getDisableBroadcast()) {
players.add(p);
}
}
MiscUtils.getInstance().broadcast(bc, players);
}
}
/**
* @return the displayName
*/
public String getDisplayName() {
return displayName;
}
/**
* @return the item
*/
public ItemBuilder getItem() {
if (item == null) {
plugin.getLogger().warning("Invalid item section in site: " + key);
return new ItemBuilder(Material.STONE, 1).setName("&cInvalid item for site: " + key)
.setLore("&cInvalid item for site: " + key);
} else {
return new ItemBuilder(item);
}
}
/**
* @return the key
*/
public String getKey() {
return key;
}
/**
* Gets the priority.
*
* @return the priority
*/
public int getPriority() {
return priority;
}
/**
* Gets the service site.
*
* @return the service site
*/
public String getServiceSite() {
return serviceSite;
}
/**
* Gets the vote delay.
*
* @return the vote delay
*/
public double getVoteDelay() {
return voteDelay;
}
/**
* Gets the vote URL.
*
* @return the vote URL
*/
public String getVoteURL() {
return voteURL;
}
/**
* Give rewards.
*
* @param user
* the user
* @param online
* the online
*/
public void giveRewards(User user, boolean online) {
new RewardBuilder(configVoteSites.getData(), configVoteSites.getRewardsPath(key)).setOnline(online)
.withPlaceHolder("ServiceSite", getServiceSite()).withPlaceHolder("SiteName", getDisplayName())
.withPlaceHolder("VoteDelay", "" + getVoteDelay()).withPlaceHolder("VoteURL", getVoteURL()).send(user);
new RewardBuilder(configVoteSites.getData(), configVoteSites.getEverySiteRewardPath()).setOnline(online)
.withPlaceHolder("ServiceSite", getServiceSite()).withPlaceHolder("SiteName", getDisplayName())
.withPlaceHolder("VoteDelay", "" + getVoteDelay()).withPlaceHolder("VoteURL", getVoteURL()).send(user);
}
/**
* Give site reward.
*
* @param user
* the user
* @param online
* the online
*/
public void giveSiteReward(User user, boolean online) {
giveRewards(user, online);
}
public boolean hasRewards() {
return RewardHandler.getInstance().hasRewards(configVoteSites.getData(), configVoteSites.getRewardsPath(key));
}
/**
* Inits the.
*/
public void init() {
setVoteURL(configVoteSites.getVoteURL(key));
setServiceSite(configVoteSites.getServiceSite(key));
setVoteDelay(configVoteSites.getVoteDelay(key));
setEnabled(configVoteSites.getVoteSiteEnabled(key));
setPriority(configVoteSites.getPriority(key));
displayName = configVoteSites.getDisplayName(key);
if (displayName == null || displayName.equals("")) {
displayName = key;
}
item = configVoteSites.getItem(key);
voteDelayDaily = configVoteSites.getVoteSiteResetVoteDelayDaily(key);
giveOffline = configVoteSites.getVoteSiteGiveOffline(key);
}
/**
* Checks if is enabled.
*
* @return true, if is enabled
*/
public boolean isEnabled() {
return enabled;
}
/**
* @return the giveOffline
*/
public boolean isGiveOffline() {
return giveOffline;
}
/**
* @return the voteDelayDaily
*/
public boolean isVoteDelayDaily() {
return voteDelayDaily;
}
/**
* @param displayName
* the displayName to set
*/
public void setDisplayName(String displayName) {
this.displayName = displayName;
}
/**
* Sets the enabled.
*
* @param enabled
* the new enabled
*/
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
/**
* @param giveOffline
* the giveOffline to set
*/
public void setGiveOffline(boolean giveOffline) {
this.giveOffline = giveOffline;
}
/**
* @param item
* the item to set
*/
public void setItem(ConfigurationSection item) {
this.item = item;
}
/**
* @param key
* the key to set
*/
public void setKey(String key) {
this.key = key;
}
/**
* Sets the priority.
*
* @param priority
* the new priority
*/
public void setPriority(int priority) {
this.priority = priority;
}
/**
* Sets the service site.
*
* @param serviceSite
* the new service site
*/
public void setServiceSite(String serviceSite) {
this.serviceSite = serviceSite;
}
/**
* Sets the vote delay.
*
* @param voteDelay
* the new vote delay
*/
public void setVoteDelay(double voteDelay) {
this.voteDelay = voteDelay;
}
/**
* @param voteDelayDaily
* the voteDelayDaily to set
*/
public void setVoteDelayDaily(boolean voteDelayDaily) {
this.voteDelayDaily = voteDelayDaily;
}
/**
* Sets the vote URL.
*
* @param voteURL
* the new vote URL
*/
public void setVoteURL(String voteURL) {
this.voteURL = voteURL;
}
}
@@ -1,287 +0,0 @@
package com.Ben12345rocks.VotingPlugin.OtherRewards;
import java.util.Set;
import org.bukkit.Bukkit;
import com.Ben12345rocks.AdvancedCore.Objects.RewardBuilder;
import com.Ben12345rocks.AdvancedCore.Objects.RewardHandler;
import com.Ben12345rocks.AdvancedCore.Util.Misc.StringUtils;
import com.Ben12345rocks.VotingPlugin.Main;
import com.Ben12345rocks.VotingPlugin.Config.Config;
import com.Ben12345rocks.VotingPlugin.Config.ConfigVoteSites;
import com.Ben12345rocks.VotingPlugin.Events.PlayerVoteAllSitesEvent;
import com.Ben12345rocks.VotingPlugin.Objects.User;
// TODO: Auto-generated Javadoc
/**
* The Class OtherVoteReward.
*/
public class OtherVoteReward {
/** The config. */
static Config config = Config.getInstance();
/** The config vote sites. */
static ConfigVoteSites configVoteSites = ConfigVoteSites.getInstance();
/** The instance. */
static OtherVoteReward instance = new OtherVoteReward();
/** The plugin. */
static Main plugin = Main.plugin;
/**
* Gets the single instance of OtherVoteReward.
*
* @return single instance of OtherVoteReward
*/
public static OtherVoteReward getInstance() {
return instance;
}
/**
* Instantiates a new other vote reward.
*/
private OtherVoteReward() {
}
/**
* Instantiates a new other vote reward.
*
* @param plugin
* the plugin
*/
public OtherVoteReward(Main plugin) {
OtherVoteReward.plugin = plugin;
}
/**
* Check all sites.
*
* @param user
* the user
* @return true, if successful
*/
public boolean checkAllSites(User user) {
boolean checkAllVotes = user.checkAllVotes();
if (checkAllVotes) {
giveAllSitesRewards(user, user.isOnline());
}
return checkAllVotes;
}
/**
* Check cumualative votes.
*
* @param user
* the user
* @return true, if successful
*/
public boolean checkCumualativeVotes(User user) {
boolean gotCumulative = false;
Set<String> votes = Config.getInstance().getCumulativeVotes();
for (String vote : votes) {
if (StringUtils.getInstance().isInt(vote)) {
int votesRequired = Integer.parseInt(vote);
if (votesRequired != 0) {
if (Config.getInstance().getCumulativeRewardEnabled(votesRequired)
&& RewardHandler.getInstance().hasRewards(Config.getInstance().getData(),
Config.getInstance().getCumulativeRewardsPath(votesRequired))) {
int total = 0;
if (Config.getInstance().getCumulativeVotesInSameDay(votesRequired)) {
total = user.getDailyTotal();
} else if (Config.getInstance().getCumulativeVotesInSameWeek(votesRequired)) {
total = user.getWeeklyTotal();
} else {
total = user.getAllTimeTotal();
}
if ((total % votesRequired) == 0 && total != 0) {
giveCumulativeVoteReward(user, user.isOnline(), votesRequired);
gotCumulative = true;
}
if (gotCumulative) {
plugin.debug(user.getPlayerName() + " got cumulative " + votesRequired);
}
}
}
} else {
plugin.debug("Invalid cumulative number: " + vote);
}
}
return gotCumulative;
}
/**
* Check first vote.
*
* @param user
* the user
* @return true, if successful
*/
public boolean checkFirstVote(User user) {
if (RewardHandler.getInstance().hasRewards(Config.getInstance().getData(),
Config.getInstance().getFirstVoteRewardsPath())) {
if (!user.hasGottenFirstVote()) {
giveFirstVoteRewards(user, user.isOnline());
return true;
}
}
return false;
}
/**
* Check milestone.
*
* @param user
* the user
* @return true, if successful
*/
public boolean checkMilestone(User user) {
boolean gotMilestone = false;
Set<String> votes = Config.getInstance().getMilestoneVotes();
for (String vote : votes) {
if (StringUtils.getInstance().isInt(vote)) {
int votesRequired = Integer.parseInt(vote);
if (votesRequired != 0) {
if (Config.getInstance().getMilestoneRewardEnabled(votesRequired)
&& RewardHandler.getInstance().hasRewards(Config.getInstance().getData(),
Config.getInstance().getMilestoneRewardsPath(votesRequired))) {
int userVotesTotal = user.getMilestoneCount();
if (userVotesTotal >= votesRequired && !user.hasGottenMilestone(votesRequired)) {
giveMilestoneVoteReward(user, user.isOnline(), votesRequired);
user.setHasGotteMilestone(votesRequired, true);
plugin.debug(user.getPlayerName() + " got milestone " + votesRequired);
}
}
}
} else {
plugin.debug("Invalid milestone number: " + vote);
}
}
return gotMilestone;
}
public boolean checkVoteStreak(User user, String type) {
boolean gotReward = false;
Set<String> streaks = Config.getInstance().getVoteStreakVotes(type);
for (String streak : streaks) {
String s = streak.replaceAll("-", "");
boolean multiple = false;
if (streak.contains("-")) {
// multiple
multiple = true;
}
if (StringUtils.getInstance().isInt(s)) {
int streakRequired = Integer.parseInt(s);
if (streakRequired != 0) {
if (Config.getInstance().getVoteStreakRewardEnabled(type, streak)
&& RewardHandler.getInstance().hasRewards(Config.getInstance().getData(),
Config.getInstance().getVoteStreakRewardsPath(type, "" + streak))) {
int curStreak = 0;
if (type.equalsIgnoreCase("day")) {
curStreak = user.getDayVoteStreak();
} else if (type.equalsIgnoreCase("week")) {
curStreak = user.getWeekVoteStreak();
} else if (type.equalsIgnoreCase("month")) {
curStreak = user.getMonthVoteStreak();
}
if (!multiple) {
if (curStreak == streakRequired) {
giveVoteStreakReward(user, user.isOnline(), type, "" + streakRequired, curStreak);
gotReward = true;
plugin.debug(
user.getPlayerName() + " got VoteStreak " + streakRequired + " for " + type);
}
} else {
if (curStreak != 0 && curStreak % streakRequired == 0) {
giveVoteStreakReward(user, user.isOnline(), type, streakRequired + "-", curStreak);
gotReward = true;
plugin.debug(
user.getPlayerName() + " got VoteStreak " + streakRequired + "* for " + type);
}
}
}
}
}
}
return gotReward;
}
/**
* Give all sites rewards.
*
* @param user
* the user
* @param online
* the online
*/
public void giveAllSitesRewards(User user, boolean online) {
PlayerVoteAllSitesEvent event = new PlayerVoteAllSitesEvent(user);
Bukkit.getPluginManager().callEvent(event);
if (event.isCancelled()) {
return;
}
RewardHandler.getInstance().giveReward(user, Config.getInstance().getData(),
Config.getInstance().getAllSitesRewardPath(), online);
}
/**
* Give cumulative vote reward.
*
* @param user
* the user
* @param online
* the online
* @param cumulative
* the cumulative
*/
public void giveCumulativeVoteReward(User user, boolean online, int cumulative) {
new RewardBuilder(Config.getInstance().getData(), Config.getInstance().getCumulativeRewardsPath(cumulative))
.setOnline(online).withPlaceHolder("Cumulative", "" + cumulative).send(user);
}
/**
* Give first vote rewards.
*
* @param user
* the user
* @param online
* the online
*/
public void giveFirstVoteRewards(User user, boolean online) {
RewardHandler.getInstance().giveReward(user, Config.getInstance().getData(),
Config.getInstance().getFirstVoteRewardsPath(), online);
}
/**
* Give milestone vote reward.
*
* @param user
* the user
* @param online
* the online
* @param milestone
* the milestone
*/
public void giveMilestoneVoteReward(User user, boolean online, int milestone) {
new RewardBuilder(Config.getInstance().getData(), Config.getInstance().getMilestoneRewardsPath(milestone))
.setOnline(online).withPlaceHolder("Milestone", "" + milestone).send(user);
}
public void giveVoteStreakReward(User user, boolean online, String type, String string, int votes) {
new RewardBuilder(Config.getInstance().getData(), Config.getInstance().getVoteStreakRewardsPath(type, string))
.setOnline(online).withPlaceHolder("Type", type).withPlaceHolder("Streak", "" + votes).send(user);
}
}
@@ -1,104 +0,0 @@
package com.Ben12345rocks.VotingPlugin.Signs;
import java.util.ArrayList;
import org.bukkit.Location;
import com.Ben12345rocks.VotingPlugin.Main;
import com.Ben12345rocks.VotingPlugin.Data.ServerData;
import com.Ben12345rocks.VotingPlugin.Objects.SignHandler;
// TODO: Auto-generated Javadoc
/**
* The Class Signs.
*/
public class Signs {
/** The instance. */
static Signs instance = new Signs();
/** The plugin. */
static Main plugin = Main.plugin;
/**
* Gets the single instance of Signs.
*
* @return single instance of Signs
*/
public static Signs getInstance() {
return instance;
}
/**
* Instantiates a new signs.
*/
private Signs() {
}
/**
* Instantiates a new signs.
*
* @param plugin
* the plugin
*/
public Signs(Main plugin) {
Signs.plugin = plugin;
}
/**
* Gets the sign from location.
*
* @param loc
* the loc
* @return the sign from location
*/
public String getSignFromLocation(Location loc) {
for (String sign : ServerData.getInstance().getSigns()) {
if (ServerData.getInstance().getSignLocation(sign).equals(loc)) {
return sign;
}
}
return null;
}
/**
* Load signs.
*/
public void loadSigns() {
plugin.signs = new ArrayList<SignHandler>();
for (String sign : ServerData.getInstance().getSigns()) {
// plugin.getLogger().info("Loading sign " + sign);
plugin.signs.add(new SignHandler(sign, ServerData.getInstance().getSignLocation(sign),
ServerData.getInstance().getSignData(sign), ServerData.getInstance().getSignPosition(sign)));
}
}
/**
* Store signs.
*/
public void storeSigns() {
for (SignHandler sign : plugin.signs) {
sign.storeSign();
}
}
/**
* Update signs.
*/
public void updateSigns() {
for (int i = plugin.signs.size() - 1; i >= 0; i--) {
if (!plugin.signs.get(i).isValid()) {
plugin.debug("Sign " + i + " invalid, removing from data.");
plugin.signs.get(i).removeSign();
plugin.signs.remove(i);
} else {
plugin.signs.get(i).updateLines();
plugin.signs.get(i).updateSign(i * 3);
}
}
plugin.debug("Signs updated");
}
}
@@ -1,668 +0,0 @@
package com.Ben12345rocks.VotingPlugin.TopVoter;
import java.io.File;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import com.Ben12345rocks.AdvancedCore.AdvancedCoreHook;
import com.Ben12345rocks.AdvancedCore.Listeners.DateChangedEvent;
import com.Ben12345rocks.AdvancedCore.Listeners.DayChangeEvent;
import com.Ben12345rocks.AdvancedCore.Listeners.MonthChangeEvent;
import com.Ben12345rocks.AdvancedCore.Listeners.PreDateChangedEvent;
import com.Ben12345rocks.AdvancedCore.Listeners.WeekChangeEvent;
import com.Ben12345rocks.AdvancedCore.Objects.UUID;
import com.Ben12345rocks.AdvancedCore.Util.Misc.ArrayUtils;
import com.Ben12345rocks.AdvancedCore.Util.Misc.StringUtils;
import com.Ben12345rocks.AdvancedCore.YML.YMLFileHandler;
import com.Ben12345rocks.VotingPlugin.Main;
import com.Ben12345rocks.VotingPlugin.Config.Config;
import com.Ben12345rocks.VotingPlugin.Objects.User;
import com.Ben12345rocks.VotingPlugin.OtherRewards.OtherVoteReward;
import com.Ben12345rocks.VotingPlugin.UserManager.UserManager;
public class TopVoterHandler implements Listener {
/** The instance. */
static TopVoterHandler instance = new TopVoterHandler();
/** The plugin. */
static Main plugin = Main.plugin;
/**
* Gets the single instance of TopVoter.
*
* @return single instance of TopVoter
*/
public static TopVoterHandler getInstance() {
return instance;
}
/**
* Instantiates a new top voter.
*/
private TopVoterHandler() {
}
public ArrayList<String> getTopVoterBlackList() {
return Config.getInstance().getBlackList();
}
/**
* Top voters weekly.
*
* @return the string[]
*/
public String[] getTopVotersWeekly() {
ArrayList<String> msg = new ArrayList<String>();
ArrayList<User> users = plugin.convertSet(plugin.topVoterWeekly.keySet());
for (int i = 0; i < users.size(); i++) {
String line = Config.getInstance().getFormatCommandVoteTopLine().replace("%num%", "" + (i + 1))
.replace("%player%", users.get(i).getPlayerName())
.replace("%votes%", "" + plugin.topVoterWeekly.get(users.get(i)));
msg.add(line);
}
msg = ArrayUtils.getInstance().colorize(msg);
return ArrayUtils.getInstance().convert(msg);
}
private HashMap<Integer, String> handlePlaces(Set<String> places) {
HashMap<Integer, String> place = new HashMap<Integer, String>();
for (String p : places) {
String[] data = p.split("-");
try {
if (data.length > 1) {
for (int i = Integer.parseInt(data[0]); i < Integer.parseInt(data[1]); i++) {
place.put(i, p);
}
} else {
place.put(Integer.parseInt(data[0]), p);
}
} catch (Exception e) {
e.printStackTrace();
}
}
return place;
}
@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
public void onDateChanged(DateChangedEvent event) {
plugin.setUpdate(true);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onDayChange(DayChangeEvent event) {
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
User user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
if (user.getDailyTotal() == 0 && user.getDayVoteStreak() != 0) {
user.setDayVoteStreak(0);
} else {
user.addDayVoteStreak();
}
OtherVoteReward.getInstance().checkVoteStreak(user, "Day");
if (user.getHighestDailyTotal() < user.getDailyTotal()) {
user.setHighestDailyTotal(user.getDailyTotal());
}
}
if (Config.getInstance().getStoreTopVotersDaily()) {
plugin.debug("Storing TopVoters Daily");
storeDailyTopVoters();
}
if (Config.getInstance().getDailyAwardsEnabled()) {
HashMap<Integer, String> places = handlePlaces(Config.getInstance().getDailyPossibleRewardPlaces());
int i = 0;
int lastTotal = -1;
for (User user : plugin.topVoterDaily.keySet()) {
if (!Config.getInstance().getTopVoterIgnorePermission() || !user.isTopVoterIgnore()) {
if (Config.getInstance().getTopVoterAwardsTies()) {
if (user.getDailyTotal() != lastTotal) {
i++;
}
} else {
i++;
}
if (places.containsKey(i)) {
user.giveDailyTopVoterAward(i, places.get(i));
}
}
lastTotal = user.getDailyTotal();
}
}
resetDailyTotals();
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onMonthChange(MonthChangeEvent event) {
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
User user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
if (user.getMonthTotal() == 0 && user.getMonthVoteStreak() != 0) {
user.setMonthVoteStreak(0);
} else {
user.addMonthVoteStreak();
OtherVoteReward.getInstance().checkVoteStreak(user, "Month");
}
if (user.getHighestMonthlyTotal() < user.getMonthTotal()) {
user.setHighestMonthlyTotal(user.getMonthTotal());
}
}
if (Config.getInstance().getStoreTopVotersMonthly()) {
plugin.debug("Storing TopVoters Monthly");
storeMonthlyTopVoters();
}
if (Config.getInstance().getMonthlyAwardsEnabled()) {
HashMap<Integer, String> places = handlePlaces(Config.getInstance().getMonthlyPossibleRewardPlaces());
int i = 0;
int lastTotal = -1;
for (User user : plugin.topVoterMonthly.keySet()) {
if (!Config.getInstance().getTopVoterIgnorePermission() || !user.isTopVoterIgnore()) {
if (Config.getInstance().getTopVoterAwardsTies()) {
if (user.getMonthTotal() != lastTotal) {
i++;
}
} else {
i++;
}
if (places.containsKey(i)) {
user.giveMonthlyTopVoterAward(i, places.get(i));
}
}
lastTotal = user.getMonthTotal();
}
}
resetMonthlyTotals();
if (Config.getInstance().getResetMilestonesMonthly()) {
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
User user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
user.setMilestoneCount(0);
user.setHasGottenMilestone(new HashMap<String, Boolean>());
}
}
}
@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
public void onPreDateChanged(PreDateChangedEvent event) {
plugin.setUpdate(true);
plugin.update();
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onWeekChange(WeekChangeEvent event) {
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
User user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
if (user.getWeeklyTotal() == 0 && user.getWeekVoteStreak() != 0) {
user.setWeekVoteStreak(0);
} else {
user.addWeekVoteStreak();
OtherVoteReward.getInstance().checkVoteStreak(user, "Week");
}
if (user.getHighestWeeklyTotal() < user.getWeeklyTotal()) {
user.setHighestWeeklyTotal(user.getWeeklyTotal());
}
}
if (Config.getInstance().getStoreTopVotersWeekly()) {
plugin.debug("Storing TopVoters Weekly");
storeWeeklyTopVoters();
}
if (Config.getInstance().getWeeklyAwardsEnabled()) {
HashMap<Integer, String> places = handlePlaces(Config.getInstance().getWeeklyPossibleRewardPlaces());
int i = 0;
int lastTotal = -1;
for (User user : plugin.topVoterWeekly.keySet()) {
if (!Config.getInstance().getTopVoterIgnorePermission() || !user.isTopVoterIgnore()) {
if (Config.getInstance().getTopVoterAwardsTies()) {
if (user.getWeeklyTotal() != lastTotal) {
i++;
}
} else {
i++;
}
if (places.containsKey(i)) {
user.giveWeeklyTopVoterAward(i, places.get(i));
}
}
lastTotal = user.getWeeklyTotal();
}
}
resetWeeklyTotals();
}
public void register() {
plugin.getServer().getPluginManager().registerEvents(this, plugin);
}
public void resetDailyTotals() {
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
User user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
if (user.getDailyTotal() != 0) {
user.resetDailyTotalVotes();
}
}
}
public void resetMonthlyTotals() {
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
User user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
if (user.getMonthTotal() != 0) {
user.resetMonthlyTotalVotes();
}
}
}
public void resetWeeklyTotals() {
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
User user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
if (user.getWeeklyTotal() != 0) {
user.resetWeeklyTotalVotes();
}
}
}
public LinkedHashMap<User, Integer> sortByValues(LinkedHashMap<User, Integer> topVoterAllTime,
final boolean order) {
List<Entry<User, Integer>> list = new LinkedList<Entry<User, Integer>>(topVoterAllTime.entrySet());
// Sorting the list based on values
Collections.sort(list, new Comparator<Entry<User, Integer>>() {
@Override
public int compare(Entry<User, Integer> o1, Entry<User, Integer> o2) {
if (order) {
return o1.getValue().compareTo(o2.getValue());
} else {
return o2.getValue().compareTo(o1.getValue());
}
}
});
// Maintaining insertion order with the help of LinkedList
LinkedHashMap<User, Integer> sortedMap = new LinkedHashMap<User, Integer>();
for (Entry<User, Integer> entry : list) {
sortedMap.put(entry.getKey(), entry.getValue());
}
return sortedMap;
}
public void storeDailyTopVoters() {
LocalDateTime time = LocalDateTime.now().minusHours(5);
String month = time.getMonth().toString();
int year = time.getYear();
int day = time.getDayOfMonth();
YMLFileHandler file = new YMLFileHandler(new File(plugin.getDataFolder(),
"TopVoter" + File.separator + "Daily" + File.separator + year + "_" + month + "_" + day + ".yml"));
file.setup();
ArrayList<String> topVoters = new ArrayList<String>();
int count = 1;
for (Entry<User, Integer> entry : plugin.topVoterDaily.entrySet()) {
topVoters.add(count + ": " + entry.getKey().getPlayerName() + ": " + entry.getValue());
count++;
}
file.getData().set("Day", topVoters);
file.saveData();
}
public void storeMonthlyTopVoters() {
LocalDateTime time = LocalDateTime.now().minusHours(10);
String month = time.getMonth().toString();
int year = time.getYear();
YMLFileHandler file = new YMLFileHandler(new File(plugin.getDataFolder(),
"TopVoter" + File.separator + "Monthly" + File.separator + month + "_" + year + ".yml"));
file.setup();
ArrayList<String> topVoters = new ArrayList<String>();
int count = 1;
for (Entry<User, Integer> entry : plugin.topVoterMonthly.entrySet()) {
topVoters.add(count + ": " + entry.getKey().getPlayerName() + ": " + entry.getValue());
count++;
}
file.getData().set("Month", topVoters);
file.saveData();
}
public void storeWeeklyTopVoters() {
LocalDateTime time = LocalDateTime.now().minusHours(10);
String month = time.getMonth().toString();
int year = time.getYear();
int week = time.getDayOfYear();
YMLFileHandler file = new YMLFileHandler(new File(plugin.getDataFolder(),
"TopVoter" + File.separator + "Weekly" + File.separator + year + "_" + month + "_" + week + ".yml"));
file.setup();
ArrayList<String> topVoters = new ArrayList<String>();
int count = 1;
for (Entry<User, Integer> entry : plugin.topVoterWeekly.entrySet()) {
topVoters.add(count + ": " + entry.getKey().getPlayerName() + ": " + entry.getValue());
count++;
}
file.getData().set("Week", topVoters);
file.saveData();
}
/**
* Top voter all time
*
* @param page
* the page
* @return the string[]
*/
public String[] topVoterAllTime(int page) {
int pagesize = Config.getInstance().getFormatPageSize();
ArrayList<String> msg = new ArrayList<String>();
ArrayList<String> topVoters = new ArrayList<String>();
int count = 1;
for (Entry<User, Integer> entry : plugin.topVoterAllTime.entrySet()) {
String line = Config.getInstance().getFormatCommandVoteTopLine();
line = line.replace("%num%", "" + count);
line = line.replace("%player%", entry.getKey().getPlayerName());
line = line.replace("%votes%", "" + entry.getValue());
topVoters.add(line);
count++;
}
int pageSize = (topVoters.size() / pagesize);
if ((topVoters.size() % pagesize) != 0) {
pageSize++;
}
String title = Config.getInstance().getFormatCommandVoteTopTitle();
title = title.replace("%page%", "" + page);
title = title.replace("%maxpages%", "" + pageSize);
title = title.replace("%Top%", "All Time");
msg.add(StringUtils.getInstance().colorize(title));
for (int i = (page - 1) * pagesize; (i < topVoters.size()) && (i < (((page - 1) * pagesize) + 10)); i++) {
msg.add(topVoters.get(i));
}
msg = ArrayUtils.getInstance().colorize(msg);
return ArrayUtils.getInstance().convert(msg);
}
/**
* Top voter weekly.
*
* @param page
* the page
* @return the string[]
*/
public String[] topVoterDaily(int page) {
int pagesize = Config.getInstance().getFormatPageSize();
ArrayList<String> msg = new ArrayList<String>();
ArrayList<String> topVoters = new ArrayList<String>();
int count = 1;
for (Entry<User, Integer> entry : plugin.topVoterDaily.entrySet()) {
String line = Config.getInstance().getFormatCommandVoteTopLine();
line = line.replace("%num%", "" + count);
line = line.replace("%player%", entry.getKey().getPlayerName());
line = line.replace("%votes%", "" + entry.getValue());
topVoters.add(line);
count++;
}
int pageSize = (topVoters.size() / pagesize);
if ((topVoters.size() % pagesize) != 0) {
pageSize++;
}
String title = Config.getInstance().getFormatCommandVoteTopTitle();
title = title.replace("%page%", "" + page);
title = title.replace("%maxpages%", "" + pageSize);
title = title.replace("%Top%", "Daily");
msg.add(StringUtils.getInstance().colorize(title));
for (int i = (page - 1) * pagesize; (i < topVoters.size()) && (i < (((page - 1) * pagesize) + 10)); i++) {
msg.add(topVoters.get(i));
}
msg = ArrayUtils.getInstance().colorize(msg);
return ArrayUtils.getInstance().convert(msg);
}
/**
* Top voter monthly
*
* @param page
* the page
* @return the string[]
*/
public String[] topVoterMonthly(int page) {
int pagesize = Config.getInstance().getFormatPageSize();
ArrayList<String> msg = new ArrayList<String>();
ArrayList<String> topVoters = new ArrayList<String>();
int count = 1;
for (Entry<User, Integer> entry : plugin.topVoterMonthly.entrySet()) {
String line = Config.getInstance().getFormatCommandVoteTopLine();
line = line.replace("%num%", "" + count);
line = line.replace("%player%", entry.getKey().getPlayerName());
line = line.replace("%votes%", "" + entry.getValue());
topVoters.add(line);
count++;
}
int pageSize = (topVoters.size() / pagesize);
if ((topVoters.size() % pagesize) != 0) {
pageSize++;
}
String title = Config.getInstance().getFormatCommandVoteTopTitle();
title = title.replace("%page%", "" + page);
title = title.replace("%maxpages%", "" + pageSize);
title = title.replace("%Top%", "Monthly");
msg.add(StringUtils.getInstance().colorize(title));
for (int i = (page - 1) * pagesize; (i < topVoters.size()) && (i < (((page - 1) * pagesize) + 10)); i++) {
msg.add(topVoters.get(i));
}
msg = ArrayUtils.getInstance().colorize(msg);
return ArrayUtils.getInstance().convert(msg);
}
/**
* Top voters all time
*
* @return the string[]
*/
public String[] topVotersAllTime() {
ArrayList<String> msg = new ArrayList<String>();
List<Entry<User, Integer>> list = new LinkedList<Entry<User, Integer>>(plugin.topVoterAllTime.entrySet());
int i = 0;
for (Entry<User, Integer> entry : list) {
String line = "%num%: %player%, %votes%";
line = line.replace("%num%", "" + (i + 1));
try {
line = line.replace("%player%", entry.getKey().getPlayerName());
} catch (Exception ex) {
AdvancedCoreHook.getInstance().debug(ex);
}
line = line.replace("%votes%", "" + entry.getValue());
msg.add(line);
i++;
}
msg = ArrayUtils.getInstance().colorize(msg);
return ArrayUtils.getInstance().convert(msg);
}
/**
* Top voters daily.
*
* @return the string[]
*/
public String[] topVotersDaily() {
ArrayList<String> msg = new ArrayList<String>();
ArrayList<User> users = plugin.convertSet(plugin.topVoterDaily.keySet());
for (int i = 0; i < users.size(); i++) {
String line = "%num%: %player%, %votes%";
line = line.replace("%num%", "" + (i + 1));
try {
line = line.replace("%player%", users.get(i).getPlayerName());
} catch (Exception ex) {
AdvancedCoreHook.getInstance().debug(ex);
}
line = line.replace("%votes%", "" + plugin.topVoterMonthly.get(users.get(i)));
msg.add(line);
}
msg = ArrayUtils.getInstance().colorize(msg);
return ArrayUtils.getInstance().convert(msg);
}
/**
* Top voters.
*
* @return the string[]
*/
public String[] topVotersMonthly() {
ArrayList<String> msg = new ArrayList<String>();
List<Entry<User, Integer>> list = new LinkedList<Entry<User, Integer>>(plugin.topVoterMonthly.entrySet());
int i = 0;
for (Entry<User, Integer> entry : list) {
String line = "%num%: %player%, %votes%";
line = line.replace("%num%", "" + (i + 1));
try {
line = line.replace("%player%", entry.getKey().getPlayerName());
} catch (Exception ex) {
AdvancedCoreHook.getInstance().debug(ex);
}
line = line.replace("%votes%", "" + entry.getValue());
msg.add(line);
i++;
}
msg = ArrayUtils.getInstance().colorize(msg);
return ArrayUtils.getInstance().convert(msg);
}
/**
* Top voter weekly.
*
* @param page
* the page
* @return the string[]
*/
public String[] topVoterWeekly(int page) {
int pagesize = Config.getInstance().getFormatPageSize();
ArrayList<String> msg = new ArrayList<String>();
ArrayList<String> topVoters = new ArrayList<String>();
int count = 1;
for (Entry<User, Integer> entry : plugin.topVoterWeekly.entrySet()) {
String line = Config.getInstance().getFormatCommandVoteTopLine();
line = line.replace("%num%", "" + count);
line = line.replace("%player%", entry.getKey().getPlayerName());
line = line.replace("%votes%", "" + entry.getValue());
topVoters.add(line);
count++;
}
int pageSize = (topVoters.size() / pagesize);
if ((topVoters.size() % pagesize) != 0) {
pageSize++;
}
String title = Config.getInstance().getFormatCommandVoteTopTitle();
title = title.replace("%page%", "" + page);
title = title.replace("%maxpages%", "" + pageSize);
title = title.replace("%Top%", "Weekly");
msg.add(StringUtils.getInstance().colorize(title));
for (int i = (page - 1) * pagesize; (i < topVoters.size()) && (i < (((page - 1) * pagesize) + 10)); i++) {
msg.add(topVoters.get(i));
}
msg = ArrayUtils.getInstance().colorize(msg);
return ArrayUtils.getInstance().convert(msg);
}
public synchronized void updateTopVoters(ArrayList<User> users1) {
ArrayList<User> users = new ArrayList<User>();
ArrayList<String> blackList = getTopVoterBlackList();
for (User user : users1) {
if (!blackList.contains(user.getPlayerName())) {
if ((!Config.getInstance().getTopVoterIgnorePermission() || !user.isTopVoterIgnore())
&& !user.isBanned()) {
users.add(user);
}
}
}
plugin.topVoterAllTime.clear();
if (Config.getInstance().getLoadTopVoterAllTime()) {
for (User user : users) {
int total = user.getAllTimeTotal();
if (total > 0) {
plugin.topVoterAllTime.put(user, total);
}
}
plugin.topVoterAllTime = sortByValues(plugin.topVoterAllTime, false);
plugin.debug("All Time TopVoter loaded");
}
plugin.topVoterMonthly.clear();
if (Config.getInstance().getLoadTopVoterMonthly()) {
for (User user : users) {
int total = user.getMonthTotal();
if (total > 0) {
plugin.topVoterMonthly.put(user, total);
}
}
plugin.topVoterMonthly = sortByValues(plugin.topVoterMonthly, false);
plugin.debug("Monthly TopVoter loaded");
}
plugin.topVoterWeekly.clear();
if (Config.getInstance().getLoadTopVoterWeekly()) {
for (User user : users) {
int total = user.getWeeklyTotal();
if (total > 0) {
plugin.topVoterWeekly.put(user, total);
}
}
plugin.topVoterWeekly = sortByValues(plugin.topVoterWeekly, false);
plugin.debug("Weekly TopVoter loaded");
}
plugin.topVoterDaily.clear();
if (Config.getInstance().getLoadTopVoterDaily()) {
for (User user : users) {
int total = user.getDailyTotal();
if (total > 0) {
plugin.topVoterDaily.put(user, total);
}
}
plugin.topVoterDaily = sortByValues(plugin.topVoterDaily, false);
plugin.debug("Daily TopVoter loaded");
}
plugin.debug("Updated TopVoter");
}
}
@@ -1,56 +0,0 @@
package com.Ben12345rocks.VotingPlugin.UserManager;
import java.util.ArrayList;
import org.bukkit.OfflinePlayer;
import org.bukkit.entity.Player;
import com.Ben12345rocks.AdvancedCore.Objects.UUID;
import com.Ben12345rocks.VotingPlugin.Main;
import com.Ben12345rocks.VotingPlugin.Objects.User;
public class UserManager {
/** The instance. */
static UserManager instance = new UserManager();
/** The plugin. */
static Main plugin = Main.plugin;
/**
* Gets the single instance of UserManager.
*
* @return single instance of UserManager
*/
public static UserManager getInstance() {
return instance;
}
public UserManager() {
super();
}
public ArrayList<String> getAllUUIDs() {
return com.Ben12345rocks.AdvancedCore.UserManager.UserManager.getInstance().getAllUUIDs();
}
public User getVotingPluginUser(java.util.UUID uuid) {
return getVotingPluginUser(new UUID(uuid.toString()));
}
public User getVotingPluginUser(OfflinePlayer player) {
return getVotingPluginUser(player.getName());
}
public User getVotingPluginUser(Player player) {
return getVotingPluginUser(player.getName());
}
@SuppressWarnings("deprecation")
public User getVotingPluginUser(String playerName) {
return new User(com.Ben12345rocks.AdvancedCore.UserManager.UserManager.getInstance().getProperName(playerName));
}
@SuppressWarnings("deprecation")
public User getVotingPluginUser(UUID uuid) {
return new User(uuid);
}
}
@@ -1,260 +0,0 @@
package com.Ben12345rocks.VotingPlugin.Util.PlaceHolders;
import java.util.Map.Entry;
import org.bukkit.OfflinePlayer;
import org.bukkit.entity.Player;
import com.Ben12345rocks.AdvancedCore.Util.Misc.StringUtils;
import com.Ben12345rocks.VotingPlugin.Main;
import com.Ben12345rocks.VotingPlugin.Commands.Commands;
import com.Ben12345rocks.VotingPlugin.Config.ConfigVoteSites;
import com.Ben12345rocks.VotingPlugin.Objects.User;
import com.Ben12345rocks.VotingPlugin.Objects.VoteSite;
import com.Ben12345rocks.VotingPlugin.UserManager.UserManager;
import com.Ben12345rocks.VotingPlugin.VoteParty.VoteParty;
// TODO: Auto-generated Javadoc
/**
* The Class PlaceHolders.
*/
public class PlaceHolders {
/** The instance. */
static PlaceHolders instance = new PlaceHolders();
/** The plugin. */
static Main plugin = Main.plugin;
/**
* Gets the single instance of PlaceHolders.
*
* @return single instance of PlaceHolders
*/
public static PlaceHolders getInstance() {
return instance;
}
/**
* Instantiates a new place holders.
*/
private PlaceHolders() {
}
/**
* Instantiates a new place holders.
*
* @param plugin
* the plugin
*/
public PlaceHolders(Main plugin) {
PlaceHolders.plugin = plugin;
}
public String getPlaceHolder(OfflinePlayer p, String identifier) {
identifier = StringUtils.getInstance().replaceJavascript(p, identifier);
// %VotingPlugin_VotePartyVotesNeeded - Number of votes needed until
// vote party rewards
if (identifier.equalsIgnoreCase("VotePartyVotesNeeded")) {
return Integer.toString(VoteParty.getInstance().getNeededVotes());
} else if (identifier.equalsIgnoreCase("VotePartyVotesCurrent")) {
return Integer.toString(VoteParty.getInstance().getTotalVotes());
} else if (identifier.equalsIgnoreCase("VotePartyVotesRequired")) {
return Integer.toString(VoteParty.getInstance().getVotesRequired());
}
User user = UserManager.getInstance().getVotingPluginUser(p);
// %VotingPlugin_total% - Total votes of all vote sites
if (identifier.equalsIgnoreCase("total")) {
return Integer.toString(user.getMonthTotal());
} else if (identifier.equalsIgnoreCase("alltimetotal")) {
return Integer.toString(user.getAllTimeTotal());
} else if (identifier.equalsIgnoreCase("lastmonthtotal")) {
return Integer.toString(user.getLastMonthTotal());
}
String[] args = identifier.split("_");
if (args.length > 1 && args[0].equalsIgnoreCase("total")) {
if (args[1].equalsIgnoreCase("all")) {
return Integer.toString(user.getAllTimeTotal());
} else if (args[1].equalsIgnoreCase("month")) {
return Integer.toString(user.getMonthTotal());
} else if (args[1].equalsIgnoreCase("week")) {
return Integer.toString(user.getWeeklyTotal());
} else if (args[1].equalsIgnoreCase("daily")) {
return Integer.toString(user.getDailyTotal());
}
}
if (identifier.equalsIgnoreCase("BestDailyTotal")) {
return "" + user.getHighestDailyTotal();
} else if (identifier.equalsIgnoreCase("BestWeeklyTotal")) {
return "" + user.getHighestWeeklyTotal();
} else if (identifier.equalsIgnoreCase("BestMonthlyTotal")) {
return "" + user.getHighestMonthlyTotal();
} else if (identifier.equalsIgnoreCase("DailyVoteStreak")) {
return "" + user.getDayVoteStreak();
} else if (identifier.equalsIgnoreCase("WeeklyVoteStreak")) {
return "" + user.getWeekVoteStreak();
} else if (identifier.equalsIgnoreCase("MonthlyVoteStreak")) {
return "" + user.getMonthVoteStreak();
} else if (identifier.equalsIgnoreCase("BestDailyVoteStreak")) {
return "" + user.getBestDayVoteStreak();
} else if (identifier.equalsIgnoreCase("BestWeeklyVoteStreak")) {
return "" + user.getBestWeekVoteStreak();
} else if (identifier.equalsIgnoreCase("BestMonthlyVoteStreak")) {
return "" + user.getBestMonthVoteStreak();
}
// %VotingPlugin_points% - Total votes of all vote sites
if (identifier.equalsIgnoreCase("points")) {
return Integer.toString(user.getPoints());
}
// %VotingPlugin_canvote% - Whether or not a player can vote on all
// sites
if (identifier.equalsIgnoreCase("canvote")) {
return Boolean.toString(user.canVoteAll());
}
// %VotingPlugin_next_SITENAME% - Next time you can vote for voteSite
if (startsWithIgnoreCase(identifier, "next")) {
if (args.length > 1) {
String str = args[1];
for (int i = 2; i < args.length; i++) {
str += "_" + args[i];
}
return playerNextVote(user, str);
} else {
return "";
}
}
// %VotingPlugin_last_SITENAME% - Next time you can vote for voteSite
if (startsWithIgnoreCase(identifier, "last")) {
if (args.length > 1) {
String str = args[1];
for (int i = 2; i < args.length; i++) {
str += "_" + args[i];
}
return playerLastVote(user, str);
}
}
if (args.length > 2) {
if (args[0].equalsIgnoreCase("top")) {
if (StringUtils.getInstance().isInt(args[2])) {
int number = Integer.parseInt(args[2]);
int num = 1;
if (args[1].equalsIgnoreCase("all")) {
for (Entry<User, Integer> entry : plugin.topVoterAllTime.entrySet()) {
if (num == number) {
if (args.length > 3 && args[3].equalsIgnoreCase("votes")) {
return "" + entry.getValue().intValue();
} else {
return entry.getKey().getPlayerName();
}
}
num++;
}
} else if (args[1].equalsIgnoreCase("month")) {
for (Entry<User, Integer> entry : plugin.topVoterMonthly.entrySet()) {
if (num == number) {
if (args.length > 3 && args[3].equalsIgnoreCase("votes")) {
return "" + entry.getValue().intValue();
} else {
return entry.getKey().getPlayerName();
}
}
num++;
}
} else if (args[1].equalsIgnoreCase("week")) {
for (Entry<User, Integer> entry : plugin.topVoterWeekly.entrySet()) {
if (num == number) {
if (args.length > 3 && args[3].equalsIgnoreCase("votes")) {
return "" + entry.getValue().intValue();
} else {
return entry.getKey().getPlayerName();
}
}
num++;
}
} else if (args[1].equalsIgnoreCase("daily")) {
for (Entry<User, Integer> entry : plugin.topVoterDaily.entrySet()) {
if (num == number) {
if (args.length > 3 && args[3].equalsIgnoreCase("votes")) {
return "" + entry.getValue().intValue();
} else {
return entry.getKey().getPlayerName();
}
}
num++;
}
}
} else if (args[2].equalsIgnoreCase("Position")) {
int num = 1;
if (args[1].equalsIgnoreCase("all")) {
for (Entry<User, Integer> entry : plugin.topVoterAllTime.entrySet()) {
if (entry.getKey().getUUID().equals(p.getUniqueId().toString())) {
return "" + num;
}
num++;
}
} else if (args[1].equalsIgnoreCase("month")) {
for (Entry<User, Integer> entry : plugin.topVoterMonthly.entrySet()) {
if (entry.getKey().getUUID().equals(p.getUniqueId().toString())) {
return "" + num;
}
num++;
}
} else if (args[1].equalsIgnoreCase("week")) {
for (Entry<User, Integer> entry : plugin.topVoterWeekly.entrySet()) {
if (entry.getKey().getUUID().equals(p.getUniqueId().toString())) {
return "" + num;
}
num++;
}
} else if (args[1].equalsIgnoreCase("daily")) {
for (Entry<User, Integer> entry : plugin.topVoterDaily.entrySet()) {
if (entry.getKey().getUUID().equals(p.getUniqueId().toString())) {
return "" + num;
}
num++;
}
}
}
}
}
return identifier;
}
public String getPlaceHolder(Player p, String identifier) {
identifier = StringUtils.getInstance().replaceJavascript(p, identifier);
return getPlaceHolder((OfflinePlayer) p, identifier);
}
public String playerLastVote(User user, String siteName) {
if (!ConfigVoteSites.getInstance().getVoteSitesNames().contains(siteName)) {
return "";
}
VoteSite voteSite = plugin.getVoteSite(siteName);
return Commands.getInstance().voteCommandLastDate(user, voteSite);
}
public String playerNextVote(User user, String siteName) {
if (!ConfigVoteSites.getInstance().getVoteSitesNames().contains(siteName)) {
return "";
}
VoteSite voteSite = plugin.getVoteSite(siteName);
return Commands.getInstance().voteCommandNextInfo(user, voteSite);
}
public boolean startsWithIgnoreCase(String str1, String str2) {
return str1.toLowerCase().startsWith(str2.toLowerCase());
}
}
@@ -1,285 +0,0 @@
package com.Ben12345rocks.VotingPlugin.VoteParty;
import java.util.ArrayList;
import java.util.HashMap;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import com.Ben12345rocks.AdvancedCore.Listeners.DayChangeEvent;
import com.Ben12345rocks.AdvancedCore.Listeners.MonthChangeEvent;
import com.Ben12345rocks.AdvancedCore.Objects.RewardBuilder;
import com.Ben12345rocks.AdvancedCore.Objects.UUID;
import com.Ben12345rocks.AdvancedCore.Util.Misc.ArrayUtils;
import com.Ben12345rocks.AdvancedCore.Util.Misc.MiscUtils;
import com.Ben12345rocks.AdvancedCore.Util.Misc.StringUtils;
import com.Ben12345rocks.VotingPlugin.Main;
import com.Ben12345rocks.VotingPlugin.Config.Config;
import com.Ben12345rocks.VotingPlugin.Data.ServerData;
import com.Ben12345rocks.VotingPlugin.Events.VotePartyEvent;
import com.Ben12345rocks.VotingPlugin.Objects.User;
import com.Ben12345rocks.VotingPlugin.UserManager.UserManager;
// TODO: Auto-generated Javadoc
/**
* The Class VoteParty.
*/
public class VoteParty implements Listener {
/** The instance. */
static VoteParty instance = new VoteParty();
/** The plugin. */
static Main plugin = Main.plugin;
/**
* Gets the single instance of VoteParty.
*
* @return single instance of VoteParty
*/
public static VoteParty getInstance() {
return instance;
}
/**
* Instantiates a new vote party.
*/
private VoteParty() {
}
/**
* Instantiates a new vote party.
*
* @param plugin
* the plugin
*/
public VoteParty(Main plugin) {
VoteParty.plugin = plugin;
}
public void addTotal(User user) {
setTotalVotes(getTotalVotes() + 1);
user.setVotePartyVotes(user.getVotePartyVotes() + 1);
}
/**
* Adds the vote player.
*
* @param user
* the user
*/
public void addVotePlayer(User user) {
String uuid = user.getUUID();
ArrayList<String> voted = getVotedUsers();
if (voted == null) {
voted = new ArrayList<String>();
}
if (!voted.contains(uuid)) {
voted.add(uuid);
setVotedUsers(voted);
}
}
/**
* Check.
*/
public void check() {
if (getTotalVotes() >= getVotesRequired()) {
setTotalVotes(getTotalVotes() - getVotesRequired());
VotePartyEvent event = new VotePartyEvent();
Bukkit.getPluginManager().callEvent(event);
if (event.isCancelled()) {
return;
}
giveRewards();
MiscUtils.getInstance().broadcast(Config.getInstance().getVotePartyBroadcast());
if (Config.getInstance().getVotePartyIncreaseVotesRquired() > 0) {
ServerData.getInstance().setVotePartyExtraRequired(ServerData.getInstance().getVotePartyExtraRequired()
+ Config.getInstance().getVotePartyIncreaseVotesRquired());
}
}
}
/**
* Command vote party.
*
* @param sender
* the sender
*/
public void commandVoteParty(CommandSender sender) {
if (Config.getInstance().getVotePartyEnabled()) {
ArrayList<String> msg = Config.getInstance().getFormatCommandsVoteParty();
int votesRequired = Config.getInstance().getVotePartyVotesRequired();
int votes = getTotalVotes();
int neededVotes = votesRequired - votes;
HashMap<String, String> placeholders = new HashMap<String, String>();
placeholders.put("votesrequired", "" + votesRequired);
placeholders.put("neededvotes", "" + neededVotes);
placeholders.put("votes", "" + votes);
msg = ArrayUtils.getInstance().colorize(ArrayUtils.getInstance().replacePlaceHolder(msg, placeholders));
sender.sendMessage(ArrayUtils.getInstance().convert(msg));
} else {
sender.sendMessage(StringUtils.getInstance().colorize("&cVoteParty not enabled"));
}
}
/**
* Gets the needed votes.
*
* @return the needed votes
*/
public int getNeededVotes() {
int votesRequired = getVotesRequired();
int votes = getTotalVotes();
int neededVotes = votesRequired - votes;
return neededVotes;
}
/**
* Gets the total votes.
*
* @return the total votes
*/
public int getTotalVotes() {
return ServerData.getInstance().getData().getInt("VoteParty.Total");
}
/**
* Gets the voted users.
*
* @return the voted users
*/
@SuppressWarnings("unchecked")
public ArrayList<String> getVotedUsers() {
ArrayList<String> list = (ArrayList<String>) ServerData.getInstance().getData().getList("VoteParty.Voted");
if (list != null) {
return list;
}
return new ArrayList<String>();
}
public int getVotesRequired() {
int required = Config.getInstance().getVotePartyVotesRequired();
int extra = ServerData.getInstance().getVotePartyExtraRequired();
if (extra > 0) {
return required + extra;
}
return required;
}
/**
* Give reward.
*
* @param user
* the user
*/
public void giveReward(User user) {
/*
* if (PlayerUtils.getInstance().isPlayerOnline(user.getPlayerName())) { if
* (user.getVotePartyVotes() >= Config.getInstance().getUserVotesRequired()) {
* RewardHandler.getInstance().giveReward(user, Config.getInstance().getData(),
* Config.getInstance().getVotePartyRewardsPath()); } } else {
* user.addOfflineOtherReward("VoteParty"); }
*/
new RewardBuilder(Config.getInstance().getData(), Config.getInstance().getVotePartyRewardsPath())
.setOnline(user.isOnline())
.withPlaceHolder("VotesRequired", "" + Config.getInstance().getVotePartyVotesRequired()).send(user);
}
/**
* Give rewards.
*/
public void giveRewards() {
for (final String cmd : Config.getInstance().getVotePartyCommands()) {
Bukkit.getScheduler().runTask(plugin, new Runnable() {
@Override
public void run() {
Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), cmd);
}
});
}
if (Config.getInstance().getVotePartyGiveAllPlayers()) {
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
User user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
giveReward(user);
}
} else {
for (String uuid : getVotedUsers()) {
User user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
giveReward(user);
}
}
reset();
}
@EventHandler
public void onDayChange(DayChangeEvent event) {
if (Config.getInstance().getVotePartyResetEachDay()) {
reset();
}
}
@EventHandler
public void onMonthChange(MonthChangeEvent event) {
if (Config.getInstance().getVotePartyResetMontly()) {
reset();
}
}
public void register() {
plugin.getServer().getPluginManager().registerEvents(this, plugin);
}
public void reset() {
setVotedUsers(new ArrayList<String>());
setTotalVotes(0);
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
User user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
if (user.getVotePartyVotes() != 0) {
user.setVotePartyVotes(0);
}
}
}
/**
* Sets the total votes.
*
* @param value
* the new total votes
*/
public void setTotalVotes(int value) {
ServerData.getInstance().getData().set("VoteParty.Total", value);
ServerData.getInstance().saveData();
}
/**
* Sets the voted users.
*
* @param value
* the new voted users
*/
public void setVotedUsers(ArrayList<String> value) {
ServerData.getInstance().getData().set("VoteParty.Voted", value);
ServerData.getInstance().saveData();
}
public synchronized void vote(User user, boolean realVote) {
if (Config.getInstance().getVotePartyEnabled()) {
if (Config.getInstance().getVotePartyCountFakeVotes() || realVote) {
addTotal(user);
addVotePlayer(user);
check();
}
}
}
}
@@ -1,127 +0,0 @@
package com.Ben12345rocks.VotingPlugin.VoteReminding;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import com.Ben12345rocks.AdvancedCore.Objects.RewardBuilder;
import com.Ben12345rocks.AdvancedCore.Util.Misc.PlayerUtils;
import com.Ben12345rocks.VotingPlugin.Main;
import com.Ben12345rocks.VotingPlugin.Config.Config;
import com.Ben12345rocks.VotingPlugin.Objects.User;
import com.Ben12345rocks.VotingPlugin.UserManager.UserManager;
// TODO: Auto-generated Javadoc
/**
* The Class VoteReminding.
*/
public class VoteReminding {
/** The instance. */
static VoteReminding instance = new VoteReminding();
/** The plugin. */
static Main plugin = Main.plugin;
/**
* Gets the single instance of VoteReminding.
*
* @return single instance of VoteReminding
*/
public static VoteReminding getInstance() {
return instance;
}
/**
* Instantiates a new vote reminding.
*/
private VoteReminding() {
}
/**
* Instantiates a new vote reminding.
*
* @param plugin
* the plugin
*/
public VoteReminding(Main plugin) {
VoteReminding.plugin = plugin;
}
/**
* Check remind.
*
* @param user
* the user
*/
public void checkRemind(User user) {
String playerName = user.getPlayerName();
if (PlayerUtils.getInstance().hasServerPermission(playerName, "VotingPlugin.Login.RemindVotes")
|| PlayerUtils.getInstance().hasServerPermission(playerName, "VotingPlugin.Player")) {
if (user.canVoteAll()) {
Player player = Bukkit.getPlayer(playerName);
if (player != null) {
if (!Config.getInstance().getVoteRemindingRemindOnlyOnce()) {
runRemind(user);
user.setReminded(true);
} else if (!user.isReminded()) {
runRemind(user);
user.setReminded(true);
}
}
}
}
}
private void giveReward(User user) {
new RewardBuilder(Config.getInstance().getData(), Config.getInstance().getVoteRemindingRewardsPath())
.setGiveOffline(false).send(user);
}
/**
* Load remind checking.
*/
public void loadRemindChecking() {
Bukkit.getScheduler().runTaskTimerAsynchronously(plugin, new Runnable() {
@Override
public void run() {
for (Player player : Bukkit.getServer().getOnlinePlayers()) {
User user = UserManager.getInstance().getVotingPluginUser(player);
checkRemind(user);
}
}
}, 10, Config.getInstance().getVoteRemindingRemindDelay() * 20 * 60);
}
/**
* Run remind.
*
* @param user
* the user
*/
public void runRemind(User user) {
if (Config.getInstance().getVoteRemindingEnabled() && user.canVoteAll() && user.shouldBeReminded()) {
user.setReminded(true);
giveReward(user);
plugin.debug(user.getPlayerName() + " was reminded!");
}
}
public void runRemindLogin(User user) {
if (Config.getInstance().getVoteRemindingEnabled()
&& (!UserManager.getInstance().getAllUUIDs().contains(user.getUUID()) || user.canVoteAll())
&& user.shouldBeReminded()) {
giveReward(user);
if (user.getData().hasData()) {
user.setReminded(true);
}
plugin.debug(user.getPlayerName() + " was reminded!");
}
}
}
@@ -1,93 +0,0 @@
package com.Ben12345rocks.VotingPlugin.VoteShop;
import org.bukkit.entity.Player;
import com.Ben12345rocks.AdvancedCore.Objects.RewardHandler;
import com.Ben12345rocks.AdvancedCore.Util.Inventory.BInventory;
import com.Ben12345rocks.AdvancedCore.Util.Inventory.BInventory.ClickEvent;
import com.Ben12345rocks.AdvancedCore.Util.Inventory.BInventoryButton;
import com.Ben12345rocks.AdvancedCore.Util.Item.ItemBuilder;
import com.Ben12345rocks.AdvancedCore.Util.Misc.StringUtils;
import com.Ben12345rocks.VotingPlugin.Main;
import com.Ben12345rocks.VotingPlugin.Commands.GUI.PlayerGUIs;
import com.Ben12345rocks.VotingPlugin.Config.Config;
import com.Ben12345rocks.VotingPlugin.Objects.User;
import com.Ben12345rocks.VotingPlugin.UserManager.UserManager;
public class VoteShop {
static VoteShop instance = new VoteShop();
static Main plugin = Main.plugin;
public static VoteShop getInstance() {
return instance;
}
private VoteShop() {
}
public VoteShop(Main plugin) {
VoteShop.plugin = plugin;
}
public void voteShop(Player player) {
if (!Config.getInstance().getVoteShopEnabled()) {
player.sendMessage(StringUtils.getInstance().colorize("&cVote shop disabled"));
return;
}
BInventory inv = new BInventory(Config.getInstance().getVoteShopName());
for (String identifier : Config.getInstance().getIdentifiers()) {
String perm = Config.getInstance().getVoteShopPermission(identifier);
boolean hasPerm = false;
if (perm.isEmpty()) {
hasPerm = true;
} else {
hasPerm = player.hasPermission(perm);
}
if (hasPerm) {
ItemBuilder builder = new ItemBuilder(Config.getInstance().getIdentifierSection(identifier));
inv.addButton(Config.getInstance().getIdentifierSlot(identifier), new BInventoryButton(builder) {
@Override
public void onClick(ClickEvent event) {
Player player = event.getWhoClicked();
User user = UserManager.getInstance().getVotingPluginUser(player);
int points = Config.getInstance().getIdentifierCost(identifier);
String identifier = Config.getInstance().getIdentifierFromSlot(event.getSlot());
if (identifier != null) {
if (user.removePoints(points)) {
RewardHandler.getInstance().giveReward(user, Config.getInstance().getData(),
Config.getInstance().getIdentifierRewardsPath(identifier));
user.sendMessage(Config.getInstance().getFormatShopPurchaseMsg()
.replace("%Identifier%", identifier).replace("%Points%", "" + points));
} else {
user.sendMessage(Config.getInstance().getFormatShopFailedMsg()
.replace("%Identifier%", identifier).replace("%Points%", "" + points));
}
}
}
});
}
}
if (Config.getInstance().getVoteShopBackButton()) {
inv.addButton(new BInventoryButton(PlayerGUIs.getInstance().getBackButton()) {
@Override
public void onClick(ClickEvent event) {
PlayerGUIs.getInstance().openVoteGUI(event.getPlayer(),
UserManager.getInstance().getVotingPluginUser(player));
}
});
}
inv.openInventory(player);
}
}
@@ -0,0 +1,290 @@
package com.bencodez.votingplugin;
import java.io.File;
import java.util.ArrayList;
import java.util.UUID;
import com.bencodez.advancedcore.api.misc.encryption.EncryptionHandler;
import com.bencodez.advancedcore.bungeeapi.pluginmessage.PluginMessageHandler;
import com.bencodez.advancedcore.bungeeapi.sockets.ClientHandler;
import com.bencodez.advancedcore.bungeeapi.sockets.SocketHandler;
import com.bencodez.advancedcore.bungeeapi.sockets.SocketReceiver;
import com.bencodez.votingplugin.bungee.BungeeMessageData;
import com.bencodez.votingplugin.bungee.BungeeMethod;
import com.bencodez.votingplugin.bungee.BungeeVersion;
import com.bencodez.votingplugin.objects.VoteSite;
import com.bencodez.votingplugin.user.UserManager;
import com.bencodez.votingplugin.user.VotingPluginUser;
import lombok.Getter;
public class BungeeHandler {
@Getter
private ClientHandler clientHandler;
private EncryptionHandler encryptionHandler;
@Getter
private BungeeMethod method;
private VotingPluginMain plugin;
@Getter
private SocketHandler socketHandler;
public BungeeHandler(VotingPluginMain plugin) {
this.plugin = plugin;
}
public void close() {
socketHandler.closeConnection();
clientHandler.stopConnection();
}
public void load() {
plugin.debug("Loading bungee handler");
method = BungeeMethod.getByName(plugin.getBungeeSettings().getBungeeMethod());
plugin.getLogger().info("Using BungeeMethod: " + method.toString());
if (method.equals(BungeeMethod.MYSQL)) {
plugin.registerBungeeChannels("vp:vp");
} else if (method.equals(BungeeMethod.PLUGINMESSAGING)) {
plugin.registerBungeeChannels("vp:vp");
plugin.getPluginMessaging().add(new PluginMessageHandler("Vote") {
@Override
public void onRecieve(String subChannel, ArrayList<String> args) {
if (args.size() > 8) {
int bungeeVersion = Integer.parseInt(args.get(8));
if (bungeeVersion != BungeeVersion.getPluginMessageVersion()) {
plugin.getLogger().warning("Incompatible version with bungee, please update all servers");
return;
}
String player = args.get(0);
String uuid = args.get(1);
String service = args.get(2);
long time = Long.parseLong(args.get(3));
plugin.debug("pluginmessaging vote received from " + player + "/" + uuid + " on " + service);
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(UUID.fromString(uuid),
player);
boolean wasOnline = Boolean.valueOf(args.get(4));
BungeeMessageData text = new BungeeMessageData(args.get(6));
boolean setTotals = Boolean.valueOf(args.get(7));
user.clearCache();
user.bungeeVotePluginMessaging(service, time, text, !setTotals, wasOnline);
if (!plugin.getBungeeSettings().isBungeeBroadcast()) {
if (wasOnline || plugin.getBungeeSettings().isBungeeBroadcastAlways()) {
VoteSite site = plugin.getVoteSite(service);
if (site != null) {
site.broadcastVote(user, false);
} else {
plugin.getLogger().warning("No votesite for " + service);
}
}
}
if (Boolean.valueOf(args.get(5))) {
plugin.getServerData().addServiceSite(service);
}
} else {
plugin.getLogger().warning("Incompatible version with bungee, please update all servers");
}
}
});
plugin.getPluginMessaging().add(new PluginMessageHandler("VoteOnline") {
@Override
public void onRecieve(String subChannel, ArrayList<String> args) {
if (args.size() > 8) {
int bungeeVersion = Integer.parseInt(args.get(8));
if (bungeeVersion != BungeeVersion.getPluginMessageVersion()) {
plugin.getLogger().warning("Incompatible version with bungee, please update all servers");
return;
}
String player = args.get(0);
String uuid = args.get(1);
String service = args.get(2);
long time = Long.parseLong(args.get(3));
BungeeMessageData text = new BungeeMessageData(args.get(6));
plugin.debug(
"pluginmessaging voteonline received from " + player + "/" + uuid + " on " + service);
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(UUID.fromString(uuid),
player);
user.clearCache();
boolean setTotals = Boolean.valueOf(args.get(7));
boolean wasOnline = Boolean.valueOf(args.get(4));
user.bungeeVotePluginMessaging(service, time, text, !setTotals, wasOnline);
if (!plugin.getBungeeSettings().isBungeeBroadcast()) {
if (Boolean.valueOf(args.get(4)) || plugin.getBungeeSettings().isBungeeBroadcastAlways()) {
VoteSite site = plugin.getVoteSite(service);
if (site != null) {
site.broadcastVote(user, false);
} else {
plugin.getLogger().warning("No votesite for " + service);
}
}
}
if (Boolean.valueOf(args.get(5))) {
plugin.getServerData().addServiceSite(service);
}
} else {
plugin.getLogger().warning("Incompatible version with bungee, please update all servers");
}
}
});
plugin.getPluginMessaging().add(new PluginMessageHandler("VoteUpdate") {
@Override
public void onRecieve(String subChannel, ArrayList<String> args) {
String player = args.get(0);
plugin.debug("pluginmessaging voteupdate received for " + player);
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(UUID.fromString(player));
user.clearCache();
user.offVote();
plugin.setUpdate(true);
}
});
plugin.getPluginMessaging().add(new PluginMessageHandler("VoteBroadcast") {
@Override
public void onRecieve(String subChannel, ArrayList<String> args) {
String uuid = args.get(0);
String service = args.get(1);
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(UUID.fromString(uuid));
VoteSite site = plugin.getVoteSite(service);
if (site != null) {
site.broadcastVote(user, false);
} else {
plugin.getLogger().warning("No votesite for " + service);
}
}
});
plugin.getPluginMessaging().add(new PluginMessageHandler("Status") {
@Override
public void onRecieve(String subChannel, ArrayList<String> args) {
String server = args.get(0);
plugin.getPluginMessaging().sendPluginMessage("statusokay", server);
}
});
} else if (method.equals(BungeeMethod.SOCKETS)) {
encryptionHandler = new EncryptionHandler(new File(plugin.getDataFolder(), "secretkey.key"));
clientHandler = new ClientHandler(plugin.getBungeeSettings().getBungeeServerHost(),
plugin.getBungeeSettings().getBungeeServerPort(), encryptionHandler,
plugin.getBungeeSettings().isBungeeDebug());
socketHandler = new SocketHandler(plugin.getVersion(), plugin.getBungeeSettings().getSpigotServerHost(),
plugin.getBungeeSettings().getSpigotServerPort(), encryptionHandler,
plugin.getBungeeSettings().isBungeeDebug());
socketHandler.add(new SocketReceiver("bungeevote") {
@Override
public void onReceive(String[] data) {
if (data.length > 5) {
plugin.extraDebug("BungeeVote from " + data[2] + ", processing");
String uuid = data[1];
VotingPluginUser user = null;
if (!uuid.isEmpty()) {
user = UserManager.getInstance().getVotingPluginUser(UUID.fromString(uuid));
} else {
user = UserManager.getInstance().getVotingPluginUser(data[2]);
}
user.clearCache();
user.bungeeVote(data[3], new BungeeMessageData(data[4]), !Boolean.valueOf(data[5]));
}
}
});
socketHandler.add(new SocketReceiver("bungeevoteonline") {
@Override
public void onReceive(String[] data) {
if (data.length > 5) {
plugin.extraDebug("BungeeVoteOnline from " + data[2] + ", processing");
String uuid = data[1];
VotingPluginUser user = null;
if (!uuid.isEmpty()) {
user = UserManager.getInstance().getVotingPluginUser(UUID.fromString(uuid));
} else {
user = UserManager.getInstance().getVotingPluginUser(data[2]);
}
user.clearCache();
user.bungeeVoteOnline(data[3], new BungeeMessageData(data[4]), !Boolean.valueOf(data[5]));
}
}
});
socketHandler.add(new SocketReceiver("BungeeBroadcast") {
@Override
public void onReceive(String[] data) {
if (data.length > 2) {
VoteSite site = plugin.getVoteSite(data[1]);
String p = data[3];
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(p);
if (site != null) {
site.broadcastVote(user, false);
} else {
plugin.getLogger().warning("No votesite for " + data[1]);
}
}
}
});
socketHandler.add(new SocketReceiver("Status") {
@Override
public void onReceive(String[] data) {
if (data.length > 0) {
plugin.getLogger().info("Received status command, sending status back");
sendData("StatusOkay", plugin.getOptions().getServer());
}
}
});
socketHandler.add(new SocketReceiver("BungeeUpdate") {
@Override
public void onReceive(String[] data) {
plugin.setUpdate(true);
}
});
if (plugin.getOptions().getServer().equalsIgnoreCase("pleaseset")) {
plugin.getLogger().warning("Server name for bungee voting is not set, please set it");
}
}
}
public void sendData(String... strings) {
clientHandler.sendMessage(strings);
}
}
@@ -0,0 +1,31 @@
package com.bencodez.votingplugin;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import com.bencodez.advancedcore.api.rewards.injected.RewardInject;
import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInject;
import com.bencodez.votingplugin.user.UserManager;
public class VotingPluginHooks {
private static VotingPluginHooks instance = new VotingPluginHooks();
public static VotingPluginHooks getInstance() {
return instance;
}
public void addCustomRequirement(RequirementInject inject) {
RewardHandler.getInstance().addInjectedRequirements(inject);
}
public void addCustomReward(RewardInject inject) {
RewardHandler.getInstance().addInjectedReward(inject);
}
public VotingPluginMain getMainClass() {
return VotingPluginMain.plugin;
}
public UserManager getUserManager() {
return UserManager.getInstance();
}
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,243 @@
package com.bencodez.votingplugin;
import com.bencodez.advancedcore.api.metrics.BStatsMetrics;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import com.bencodez.votingplugin.user.UserManager;
public class VotingPluginMetrics {
public void load(VotingPluginMain plugin) {
BStatsMetrics metrics = new BStatsMetrics(plugin);
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_firstvote") {
@Override
public String getValue() {
if (RewardHandler.getInstance().hasRewards(plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getFirstVoteRewardsPath())) {
return "True";
} else {
return "False";
}
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_everysite") {
@Override
public String getValue() {
if (RewardHandler.getInstance().hasRewards(plugin.getConfigVoteSites().getData(),
plugin.getConfigVoteSites().getEverySiteRewardPath())) {
return "True";
} else {
return "False";
}
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_allsites") {
@Override
public String getValue() {
if (RewardHandler.getInstance().hasRewards(plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getAllSitesRewardPath())) {
return "True";
} else {
return "False";
}
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_cumulative") {
@Override
public String getValue() {
if (plugin.getSpecialRewardsConfig().getCumulativeVotes().size() == 0) {
return "False";
} else {
for (String cum : plugin.getSpecialRewardsConfig().getCumulativeVotes()) {
if (plugin.getSpecialRewardsConfig().getCumulativeRewardEnabled(Integer.parseInt(cum))) {
return "True";
}
}
return "False";
}
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_voteparty") {
@Override
public String getValue() {
if (!plugin.getSpecialRewardsConfig().getVotePartyEnabled()) {
return "False";
} else {
return "True";
}
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_milestone") {
@Override
public String getValue() {
if (plugin.getSpecialRewardsConfig().getMilestoneVotes().size() == 0) {
return "False";
} else {
for (String milestone : plugin.getSpecialRewardsConfig().getMilestoneVotes()) {
if (plugin.getSpecialRewardsConfig().getMilestoneRewardEnabled(Integer.parseInt(milestone))) {
return "True";
}
}
return "False";
}
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_anysitereward") {
@Override
public String getValue() {
if (RewardHandler.getInstance().hasRewards(plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getAnySiteRewardsPath())) {
return "True";
} else {
return "False";
}
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_votestreakday") {
@Override
public String getValue() {
for (String s : plugin.getSpecialRewardsConfig().getVoteStreakVotes("Day")) {
if (plugin.getSpecialRewardsConfig().getVoteStreakRewardEnabled("Day", s)
&& RewardHandler.getInstance().hasRewards(plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getVoteStreakRewardsPath("Day", s))) {
return "True";
}
}
return "False";
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_votestreakweek") {
@Override
public String getValue() {
for (String s : plugin.getSpecialRewardsConfig().getVoteStreakVotes("Week")) {
if (plugin.getSpecialRewardsConfig().getVoteStreakRewardEnabled("Week", s)
&& RewardHandler.getInstance().hasRewards(plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getVoteStreakRewardsPath("Week", s))) {
return "True";
}
}
return "False";
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_votestreakmonth") {
@Override
public String getValue() {
for (String s : plugin.getSpecialRewardsConfig().getVoteStreakVotes("Month")) {
if (plugin.getSpecialRewardsConfig().getVoteStreakRewardEnabled("Month", s)
&& RewardHandler.getInstance().hasRewards(plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getVoteStreakRewardsPath("Month", s))) {
return "True";
}
}
return "False";
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("numberofsites") {
@Override
public String getValue() {
return "" + plugin.getVoteSites().size();
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("numberofrewards") {
@Override
public String getValue() {
return "" + RewardHandler.getInstance().getRewards().size();
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("autocreatevotesites") {
@Override
public String getValue() {
return "" + plugin.getConfigFile().isAutoCreateVoteSites();
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("numberofusers") {
@Override
public String getValue() {
int total = UserManager.getInstance().getAllUUIDs().size();
if (total < 1000) {
return "<1000";
} else if (total > 10000) {
return ">10000";
} else {
return "1000-10000";
}
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("data_storage") {
@Override
public String getValue() {
return plugin.getOptions().getStorageType().toString();
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("DisableCheckOnWorldChange") {
@Override
public String getValue() {
return "" + plugin.getOptions().isDisableCheckOnWorldChange();
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("votereminding_enabled") {
@Override
public String getValue() {
return "" + plugin.getConfigFile().getVoteRemindingEnabled();
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("LoadTopVoter_Monthly") {
@Override
public String getValue() {
return "" + plugin.getConfigFile().getLoadTopVoterMonthly();
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("LoadTopVoter_Weekly") {
@Override
public String getValue() {
return "" + plugin.getConfigFile().getLoadTopVoterWeekly();
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("LoadTopVoter_Daily") {
@Override
public String getValue() {
return "" + plugin.getConfigFile().getLoadTopVoterDaily();
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("bungeemethod") {
@Override
public String getValue() {
if (plugin.getBungeeSettings().isUseBungeecoord()) {
return "" + plugin.getBungeeHandler().getMethod().toString();
} else {
return "Disabled";
}
}
});
}
}
@@ -0,0 +1,67 @@
package com.bencodez.votingplugin.broadcast;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ConcurrentLinkedQueue;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.messages.StringParser;
import com.bencodez.advancedcore.api.misc.MiscUtils;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.user.UserManager;
public class BroadcastHandler {
ConcurrentLinkedQueue<String> votedPlayers = new ConcurrentLinkedQueue<String>();
private Timer timer;
private VotingPluginMain plugin;
public BroadcastHandler(VotingPluginMain plugin, int delay) {
this.plugin = plugin;
schelude(delay);
}
public void schelude(int delay) {
if (timer != null) {
timer.cancel();
} else {
timer = new Timer();
}
timer.schedule(new TimerTask() {
@Override
public void run() {
check();
}
}, 1000 * 60, 1000 * 60 * delay);
}
public void onVote(String player) {
votedPlayers.add(player);
}
public void check() {
int size = votedPlayers.size();
if (size > 0) {
for (int i = 0; i < size; i++) {
votedPlayers.poll();
}
String bc = StringParser.getInstance()
.colorize(plugin.getConfigFile().getFormatAlternateBroadcastBroadcast());
HashMap<String, String> placeholders = new HashMap<String, String>();
placeholders.put("numberofplayers", "" + size);
bc = StringParser.getInstance().replacePlaceHolder(bc, placeholders);
ArrayList<Player> players = new ArrayList<Player>();
for (Player p : Bukkit.getOnlinePlayers()) {
if (!UserManager.getInstance().getVotingPluginUser(p).getDisableBroadcast()) {
players.add(p);
}
}
MiscUtils.getInstance().broadcast(bc, players);
}
}
}
@@ -0,0 +1,771 @@
package com.bencodez.votingplugin.bungee;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.zip.GZIPOutputStream;
import javax.net.ssl.HttpsURLConnection;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonPrimitive;
import net.md_5.bungee.api.plugin.Plugin;
import net.md_5.bungee.config.Configuration;
import net.md_5.bungee.config.ConfigurationProvider;
import net.md_5.bungee.config.YamlConfiguration;
/**
* bStats collects some data for plugin authors.
* <p>
* Check out https://bStats.org/ to learn more about bStats!
*/
public class BStatsMetricsBungee {
static {
// You can use the property to disable the check in your test environment
if (System.getProperty("bstats.relocatecheck") == null
|| !System.getProperty("bstats.relocatecheck").equals("false")) {
// Maven's Relocate is clever and changes strings, too. So we have to use this
// little "trick" ... :D
final String defaultPackage = new String(new byte[] { 'o', 'r', 'g', '.', 'b', 's', 't', 'a', 't', 's', '.',
'b', 'u', 'n', 'g', 'e', 'e', 'c', 'o', 'r', 'd' });
final String examplePackage = new String(
new byte[] { 'y', 'o', 'u', 'r', '.', 'p', 'a', 'c', 'k', 'a', 'g', 'e' });
// We want to make sure nobody just copy & pastes the example and use the wrong
// package names
if (BStatsMetricsBungee.class.getPackage().getName().equals(defaultPackage)
|| BStatsMetricsBungee.class.getPackage().getName().equals(examplePackage)) {
throw new IllegalStateException("bStats Metrics class has not been relocated correctly!");
}
}
}
// The version of this bStats class
public static final int B_STATS_VERSION = 1;
// The url to which the data is sent
private static final String URL = "https://bStats.org/submitData/bungeecord";
// The plugin
private final Plugin plugin;
// The plugin id
private final int pluginId;
// Is bStats enabled on this server?
private boolean enabled;
// The uuid of the server
private String serverUUID;
// Should failed requests be logged?
private boolean logFailedRequests = false;
// Should the sent data be logged?
private static boolean logSentData;
// Should the response text be logged?
private static boolean logResponseStatusText;
// A list with all known metrics class objects including this one
private static final List<Object> knownMetricsInstances = new ArrayList<>();
// A list with all custom charts
private final List<CustomChart> charts = new ArrayList<>();
/**
* Class constructor.
*
* @param plugin The plugin which stats should be submitted.
* @param pluginId The id of the plugin. It can be found at
* <a href="https://bstats.org/what-is-my-plugin-id">What is my
* plugin id?</a>
*/
public BStatsMetricsBungee(Plugin plugin, int pluginId) {
this.plugin = plugin;
this.pluginId = pluginId;
try {
loadConfig();
} catch (IOException e) {
// Failed to load configuration
plugin.getLogger().log(Level.WARNING, "Failed to load bStats config!", e);
return;
}
// We are not allowed to send data about this server :(
if (!enabled) {
return;
}
Class<?> usedMetricsClass = getFirstBStatsClass();
if (usedMetricsClass == null) {
// Failed to get first metrics class
return;
}
if (usedMetricsClass == getClass()) {
// We are the first! :)
linkMetrics(this);
startSubmitting();
} else {
// We aren't the first so we link to the first metrics class
try {
usedMetricsClass.getMethod("linkMetrics", Object.class).invoke(null, this);
} catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
if (logFailedRequests) {
plugin.getLogger().log(Level.WARNING,
"Failed to link to first metrics class " + usedMetricsClass.getName() + "!", e);
}
}
}
}
/**
* Checks if bStats is enabled.
*
* @return Whether bStats is enabled or not.
*/
public boolean isEnabled() {
return enabled;
}
/**
* Adds a custom chart.
*
* @param chart The chart to add.
*/
public void addCustomChart(CustomChart chart) {
if (chart == null) {
plugin.getLogger().log(Level.WARNING, "Chart cannot be null");
}
charts.add(chart);
}
/**
* Links an other metrics class with this class. This method is called using
* Reflection.
*
* @param metrics An object of the metrics class to link.
*/
public static void linkMetrics(Object metrics) {
knownMetricsInstances.add(metrics);
}
/**
* Gets the plugin specific data. This method is called using Reflection.
*
* @return The plugin specific data.
*/
public JsonObject getPluginData() {
JsonObject data = new JsonObject();
String pluginName = plugin.getDescription().getName();
String pluginVersion = plugin.getDescription().getVersion();
data.addProperty("pluginName", pluginName);
data.addProperty("id", pluginId);
data.addProperty("pluginVersion", pluginVersion);
JsonArray customCharts = new JsonArray();
for (CustomChart customChart : charts) {
// Add the data of the custom charts
JsonObject chart = customChart.getRequestJsonObject(plugin.getLogger(), logFailedRequests);
if (chart == null) { // If the chart is null, we skip it
continue;
}
customCharts.add(chart);
}
data.add("customCharts", customCharts);
return data;
}
private void startSubmitting() {
// The data collection is async, as well as sending the data
// Bungeecord does not have a main thread, everything is async
plugin.getProxy().getScheduler().schedule(plugin, this::submitData, 2, 30, TimeUnit.MINUTES);
// Submit the data every 30 minutes, first time after 2 minutes to give other
// plugins enough time to start
// WARNING: Changing the frequency has no effect but your plugin WILL be
// blocked/deleted!
// WARNING: Just don't do it!
}
/**
* Gets the server specific data.
*
* @return The server specific data.
*/
@SuppressWarnings("deprecation")
private JsonObject getServerData() {
// Minecraft specific data
int playerAmount = Math.min(plugin.getProxy().getOnlineCount(), 500);
int onlineMode = plugin.getProxy().getConfig().isOnlineMode() ? 1 : 0;
String bungeecordVersion = plugin.getProxy().getVersion();
int managedServers = plugin.getProxy().getServers().size();
// OS/Java specific data
String javaVersion = System.getProperty("java.version");
String osName = System.getProperty("os.name");
String osArch = System.getProperty("os.arch");
String osVersion = System.getProperty("os.version");
int coreCount = Runtime.getRuntime().availableProcessors();
JsonObject data = new JsonObject();
data.addProperty("serverUUID", serverUUID);
data.addProperty("playerAmount", playerAmount);
data.addProperty("managedServers", managedServers);
data.addProperty("onlineMode", onlineMode);
data.addProperty("bungeecordVersion", bungeecordVersion);
data.addProperty("javaVersion", javaVersion);
data.addProperty("osName", osName);
data.addProperty("osArch", osArch);
data.addProperty("osVersion", osVersion);
data.addProperty("coreCount", coreCount);
return data;
}
/**
* Collects the data and sends it afterwards.
*/
private void submitData() {
final JsonObject data = getServerData();
final JsonArray pluginData = new JsonArray();
// Search for all other bStats Metrics classes to get their plugin data
for (Object metrics : knownMetricsInstances) {
try {
Object plugin = metrics.getClass().getMethod("getPluginData").invoke(metrics);
if (plugin instanceof JsonObject) {
pluginData.add((JsonObject) plugin);
}
} catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException ignored) {
}
}
data.add("plugins", pluginData);
try {
// Send the data
sendData(plugin, data);
} catch (Exception e) {
// Something went wrong! :(
if (logFailedRequests) {
plugin.getLogger().log(Level.WARNING, "Could not submit plugin stats!", e);
}
}
}
/**
* Loads the bStats configuration.
*
* @throws IOException If something did not work :(
*/
private void loadConfig() throws IOException {
File bStatsFolder = new File(plugin.getDataFolder().getParentFile(), "bStats");
bStatsFolder.mkdirs();
File configFile = new File(bStatsFolder, "config.yml");
if (!configFile.exists()) {
writeFile(configFile,
"#bStats collects some data for plugin authors like how many servers are using their plugins.",
"#To honor their work, you should not disable it.",
"#This has nearly no effect on the server performance!",
"#Check out https://bStats.org/ to learn more :)", "enabled: true",
"serverUuid: \"" + UUID.randomUUID() + "\"", "logFailedRequests: false", "logSentData: false",
"logResponseStatusText: false");
}
Configuration configuration = ConfigurationProvider.getProvider(YamlConfiguration.class).load(configFile);
// Load configuration
enabled = configuration.getBoolean("enabled", true);
serverUUID = configuration.getString("serverUuid");
logFailedRequests = configuration.getBoolean("logFailedRequests", false);
logSentData = configuration.getBoolean("logSentData", false);
logResponseStatusText = configuration.getBoolean("logResponseStatusText", false);
}
/**
* Gets the first bStat Metrics class.
*
* @return The first bStats metrics class.
*/
private Class<?> getFirstBStatsClass() {
File bStatsFolder = new File(plugin.getDataFolder().getParentFile(), "bStats");
bStatsFolder.mkdirs();
File tempFile = new File(bStatsFolder, "temp.txt");
try {
String className = readFile(tempFile);
if (className != null) {
try {
// Let's check if a class with the given name exists.
return Class.forName(className);
} catch (ClassNotFoundException ignored) {
}
}
writeFile(tempFile, getClass().getName());
return getClass();
} catch (IOException e) {
if (logFailedRequests) {
plugin.getLogger().log(Level.WARNING, "Failed to get first bStats class!", e);
}
return null;
}
}
/**
* Reads the first line of the file.
*
* @param file The file to read. Cannot be null.
* @return The first line of the file or {@code null} if the file does not exist
* or is empty.
* @throws IOException If something did not work :(
*/
private String readFile(File file) throws IOException {
if (!file.exists()) {
return null;
}
try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) {
return bufferedReader.readLine();
}
}
/**
* Writes a String to a file. It also adds a note for the user,
*
* @param file The file to write to. Cannot be null.
* @param lines The lines to write.
* @throws IOException If something did not work :(
*/
private void writeFile(File file, String... lines) throws IOException {
try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file))) {
for (String line : lines) {
bufferedWriter.write(line);
bufferedWriter.newLine();
}
}
}
/**
* Sends the data to the bStats server.
*
* @param plugin Any plugin. It's just used to get a logger instance.
* @param data The data to send.
* @throws Exception If the request failed.
*/
private static void sendData(Plugin plugin, JsonObject data) throws Exception {
if (data == null) {
throw new IllegalArgumentException("Data cannot be null");
}
if (logSentData) {
plugin.getLogger().info("Sending data to bStats: " + data);
}
HttpsURLConnection connection = (HttpsURLConnection) new URL(URL).openConnection();
// Compress the data to save bandwidth
byte[] compressedData = compress(data.toString());
// Add headers
connection.setRequestMethod("POST");
connection.addRequestProperty("Accept", "application/json");
connection.addRequestProperty("Connection", "close");
connection.addRequestProperty("Content-Encoding", "gzip"); // We gzip our request
connection.addRequestProperty("Content-Length", String.valueOf(compressedData.length));
connection.setRequestProperty("Content-Type", "application/json"); // We send our data in JSON format
connection.setRequestProperty("User-Agent", "MC-Server/" + B_STATS_VERSION);
// Send data
connection.setDoOutput(true);
try (DataOutputStream outputStream = new DataOutputStream(connection.getOutputStream())) {
outputStream.write(compressedData);
}
StringBuilder builder = new StringBuilder();
try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
String line;
while ((line = bufferedReader.readLine()) != null) {
builder.append(line);
}
}
if (logResponseStatusText) {
plugin.getLogger().info("Sent data to bStats and received response: " + builder);
}
}
/**
* Gzips the given String.
*
* @param str The string to gzip.
* @return The gzipped String.
* @throws IOException If the compression failed.
*/
private static byte[] compress(final String str) throws IOException {
if (str == null) {
return null;
}
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
try (GZIPOutputStream gzip = new GZIPOutputStream(outputStream)) {
gzip.write(str.getBytes(StandardCharsets.UTF_8));
}
return outputStream.toByteArray();
}
/**
* Represents a custom chart.
*/
public static abstract class CustomChart {
// The id of the chart
private final String chartId;
/**
* Class constructor.
*
* @param chartId The id of the chart.
*/
CustomChart(String chartId) {
if (chartId == null || chartId.isEmpty()) {
throw new IllegalArgumentException("ChartId cannot be null or empty!");
}
this.chartId = chartId;
}
private JsonObject getRequestJsonObject(Logger logger, boolean logFailedRequests) {
JsonObject chart = new JsonObject();
chart.addProperty("chartId", chartId);
try {
JsonObject data = getChartData();
if (data == null) {
// If the data is null we don't send the chart.
return null;
}
chart.add("data", data);
} catch (Throwable t) {
if (logFailedRequests) {
logger.log(Level.WARNING, "Failed to get data for custom chart with id " + chartId, t);
}
return null;
}
return chart;
}
protected abstract JsonObject getChartData() throws Exception;
}
/**
* Represents a custom simple pie.
*/
public static class SimplePie extends CustomChart {
private final Callable<String> callable;
/**
* Class constructor.
*
* @param chartId The id of the chart.
* @param callable The callable which is used to request the chart data.
*/
public SimplePie(String chartId, Callable<String> callable) {
super(chartId);
this.callable = callable;
}
@Override
protected JsonObject getChartData() throws Exception {
JsonObject data = new JsonObject();
String value = callable.call();
if (value == null || value.isEmpty()) {
// Null = skip the chart
return null;
}
data.addProperty("value", value);
return data;
}
}
/**
* Represents a custom advanced pie.
*/
public static class AdvancedPie extends CustomChart {
private final Callable<Map<String, Integer>> callable;
/**
* Class constructor.
*
* @param chartId The id of the chart.
* @param callable The callable which is used to request the chart data.
*/
public AdvancedPie(String chartId, Callable<Map<String, Integer>> callable) {
super(chartId);
this.callable = callable;
}
@Override
protected JsonObject getChartData() throws Exception {
JsonObject data = new JsonObject();
JsonObject values = new JsonObject();
Map<String, Integer> map = callable.call();
if (map == null || map.isEmpty()) {
// Null = skip the chart
return null;
}
boolean allSkipped = true;
for (Map.Entry<String, Integer> entry : map.entrySet()) {
if (entry.getValue() == 0) {
continue; // Skip this invalid
}
allSkipped = false;
values.addProperty(entry.getKey(), entry.getValue());
}
if (allSkipped) {
// Null = skip the chart
return null;
}
data.add("values", values);
return data;
}
}
/**
* Represents a custom drilldown pie.
*/
public static class DrilldownPie extends CustomChart {
private final Callable<Map<String, Map<String, Integer>>> callable;
/**
* Class constructor.
*
* @param chartId The id of the chart.
* @param callable The callable which is used to request the chart data.
*/
public DrilldownPie(String chartId, Callable<Map<String, Map<String, Integer>>> callable) {
super(chartId);
this.callable = callable;
}
@Override
public JsonObject getChartData() throws Exception {
JsonObject data = new JsonObject();
JsonObject values = new JsonObject();
Map<String, Map<String, Integer>> map = callable.call();
if (map == null || map.isEmpty()) {
// Null = skip the chart
return null;
}
boolean reallyAllSkipped = true;
for (Map.Entry<String, Map<String, Integer>> entryValues : map.entrySet()) {
JsonObject value = new JsonObject();
boolean allSkipped = true;
for (Map.Entry<String, Integer> valueEntry : map.get(entryValues.getKey()).entrySet()) {
value.addProperty(valueEntry.getKey(), valueEntry.getValue());
allSkipped = false;
}
if (!allSkipped) {
reallyAllSkipped = false;
values.add(entryValues.getKey(), value);
}
}
if (reallyAllSkipped) {
// Null = skip the chart
return null;
}
data.add("values", values);
return data;
}
}
/**
* Represents a custom single line chart.
*/
public static class SingleLineChart extends CustomChart {
private final Callable<Integer> callable;
/**
* Class constructor.
*
* @param chartId The id of the chart.
* @param callable The callable which is used to request the chart data.
*/
public SingleLineChart(String chartId, Callable<Integer> callable) {
super(chartId);
this.callable = callable;
}
@Override
protected JsonObject getChartData() throws Exception {
JsonObject data = new JsonObject();
int value = callable.call();
if (value == 0) {
// Null = skip the chart
return null;
}
data.addProperty("value", value);
return data;
}
}
/**
* Represents a custom multi line chart.
*/
public static class MultiLineChart extends CustomChart {
private final Callable<Map<String, Integer>> callable;
/**
* Class constructor.
*
* @param chartId The id of the chart.
* @param callable The callable which is used to request the chart data.
*/
public MultiLineChart(String chartId, Callable<Map<String, Integer>> callable) {
super(chartId);
this.callable = callable;
}
@Override
protected JsonObject getChartData() throws Exception {
JsonObject data = new JsonObject();
JsonObject values = new JsonObject();
Map<String, Integer> map = callable.call();
if (map == null || map.isEmpty()) {
// Null = skip the chart
return null;
}
boolean allSkipped = true;
for (Map.Entry<String, Integer> entry : map.entrySet()) {
if (entry.getValue() == 0) {
continue; // Skip this invalid
}
allSkipped = false;
values.addProperty(entry.getKey(), entry.getValue());
}
if (allSkipped) {
// Null = skip the chart
return null;
}
data.add("values", values);
return data;
}
}
/**
* Represents a custom simple bar chart.
*/
public static class SimpleBarChart extends CustomChart {
private final Callable<Map<String, Integer>> callable;
/**
* Class constructor.
*
* @param chartId The id of the chart.
* @param callable The callable which is used to request the chart data.
*/
public SimpleBarChart(String chartId, Callable<Map<String, Integer>> callable) {
super(chartId);
this.callable = callable;
}
@Override
protected JsonObject getChartData() throws Exception {
JsonObject data = new JsonObject();
JsonObject values = new JsonObject();
Map<String, Integer> map = callable.call();
if (map == null || map.isEmpty()) {
// Null = skip the chart
return null;
}
for (Map.Entry<String, Integer> entry : map.entrySet()) {
JsonArray categoryValues = new JsonArray();
categoryValues.add(new JsonPrimitive(entry.getValue()));
values.add(entry.getKey(), categoryValues);
}
data.add("values", values);
return data;
}
}
/**
* Represents a custom advanced bar chart.
*/
public static class AdvancedBarChart extends CustomChart {
private final Callable<Map<String, int[]>> callable;
/**
* Class constructor.
*
* @param chartId The id of the chart.
* @param callable The callable which is used to request the chart data.
*/
public AdvancedBarChart(String chartId, Callable<Map<String, int[]>> callable) {
super(chartId);
this.callable = callable;
}
@Override
protected JsonObject getChartData() throws Exception {
JsonObject data = new JsonObject();
JsonObject values = new JsonObject();
Map<String, int[]> map = callable.call();
if (map == null || map.isEmpty()) {
// Null = skip the chart
return null;
}
boolean allSkipped = true;
for (Map.Entry<String, int[]> entry : map.entrySet()) {
if (entry.getValue().length == 0) {
continue; // Skip this invalid
}
allSkipped = false;
JsonArray categoryValues = new JsonArray();
for (int categoryValue : entry.getValue()) {
categoryValues.add(new JsonPrimitive(categoryValue));
}
values.add(entry.getKey(), categoryValues);
}
if (allSkipped) {
// Null = skip the chart
return null;
}
data.add("values", values);
return data;
}
}
}
@@ -0,0 +1,53 @@
package com.bencodez.votingplugin.bungee;
import java.util.regex.Pattern;
import lombok.Getter;
public class BungeeMessageData {
// Message string
// alltimetotal//monthtotal//weeklytotal//dailytotal//points//milestonecount
@Getter
private int allTimeTotal = 0;
@Getter
private int monthTotal = 0;
@Getter
private int weeklyTotal = 0;
@Getter
private int dailyTotal = 0;
@Getter
private int points = 0;
@Getter
private int milestoneCount = 0;
public BungeeMessageData(String str) {
String[] data = str.split(Pattern.quote("//"));
if (data.length >= 6) {
allTimeTotal = Integer.parseInt(data[0]);
monthTotal = Integer.parseInt(data[1]);
weeklyTotal = Integer.parseInt(data[2]);
dailyTotal = Integer.parseInt(data[3]);
points = Integer.parseInt(data[4]);
milestoneCount = Integer.parseInt(data[5]);
}
}
@Override
public String toString() {
return allTimeTotal + "//" + monthTotal + "//" + weeklyTotal + "//" + dailyTotal + "//" + points + "//"
+ milestoneCount;
}
public BungeeMessageData(int allTimeTotal, int monthTotal, int weeklyTotal, int dailyTotal, int points,
int milestoneCount) {
this.allTimeTotal = allTimeTotal;
this.monthTotal = monthTotal;
this.weeklyTotal = weeklyTotal;
this.dailyTotal = dailyTotal;
this.points = points;
this.milestoneCount = milestoneCount;
}
}
@@ -0,0 +1,14 @@
package com.bencodez.votingplugin.bungee;
public enum BungeeMethod {
MYSQL, PLUGINMESSAGING, SOCKETS;
public static BungeeMethod getByName(String str) {
for (BungeeMethod method : values()) {
if (method.toString().equalsIgnoreCase(str)) {
return method;
}
}
return SOCKETS;
}
}
@@ -0,0 +1,472 @@
package com.bencodez.votingplugin.bungee;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import com.bencodez.advancedcore.api.user.userstorage.mysql.api.queries.Query;
import com.bencodez.advancedcore.api.user.userstorage.sql.Column;
import com.bencodez.advancedcore.api.user.userstorage.sql.DataType;
import net.md_5.bungee.config.Configuration;
public class BungeeMySQL {
private List<String> columns = Collections.synchronizedList(new ArrayList<String>());
private List<String> intColumns = new ArrayList<String>();
// private HashMap<String, ArrayList<Column>> table;
// ConcurrentMap<String, ArrayList<Column>> table = new
// ConcurrentHashMap<String, ArrayList<Column>>();
private com.bencodez.advancedcore.api.user.userstorage.mysql.api.MySQL mysql;
private String name;
private Object object2 = new Object();
private Object object3 = new Object();
private Object object4 = new Object();
private Set<String> uuids = Collections.synchronizedSet(new HashSet<String>());
public BungeeMySQL(String tableName, Configuration section) {
String tablePrefix = section.getString("Prefix");
String hostName = section.getString("Host");
int port = section.getInt("Port");
String user = section.getString("Username");
String pass = section.getString("Password");
String database = section.getString("Database");
long lifeTime = section.getLong("MaxLifeTime", -1);
int maxThreads = section.getInt("MaxConnections", 1);
String str = section.getString("Line", "");
if (maxThreads < 1) {
maxThreads = 1;
}
boolean useSSL = section.getBoolean("UseSSL", false);
boolean publicKeyRetrieval = section.getBoolean("PublicKeyRetrieval", false);
if (!section.getString("Name", "").isEmpty()) {
tableName = section.getString("Name", "");
}
name = tableName;
if (tablePrefix != null) {
name = tablePrefix + tableName;
}
mysql = new com.bencodez.advancedcore.api.user.userstorage.mysql.api.MySQL(maxThreads);
if (!mysql.connect(hostName, "" + port, user, pass, database, useSSL, lifeTime, str, publicKeyRetrieval)) {
}
try {
Query q = new Query(mysql, "USE " + database + ";");
q.executeUpdateAsync();
} catch (SQLException e) {
e.printStackTrace();
}
String sql = "CREATE TABLE IF NOT EXISTS " + getName() + " (";
sql += "uuid VARCHAR(37),";
sql += "PRIMARY KEY ( uuid )";
sql += ");";
Query query;
try {
query = new Query(mysql, sql);
query.executeUpdateAsync();
} catch (SQLException e) {
e.printStackTrace();
}
loadData();
// tempoary to improve performance from old tables
// addToQue("ALTER TABLE " + getName() + " MODIFY uuid VARCHAR(37);");
alterColumnType("uuid", "VARCHAR(37)");
}
public void addColumn(String column, DataType dataType) {
synchronized (object3) {
String sql = "ALTER TABLE " + getName() + " ADD COLUMN " + column + " text" + ";";
try {
Query query = new Query(mysql, sql);
query.executeUpdate();
getColumns().add(column);
} catch (SQLException e) {
e.printStackTrace();
}
}
}
public void alterColumnType(String column, String newType) {
checkColumn(column, DataType.STRING);
if (newType.contains("INT")) {
try {
new Query(mysql, "UPDATE " + getName() + " SET " + column + " = '0' where trim(coalesce(" + column
+ ", '')) = '';").executeUpdateAsync();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
;
if (!intColumns.contains(column)) {
intColumns.add(column);
}
}
try {
new Query(mysql, "ALTER TABLE " + getName() + " MODIFY " + column + " " + newType + ";")
.executeUpdateAsync();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void checkColumn(String column, DataType dataType) {
synchronized (object4) {
if (!getColumns().contains(column)) {
if (!getColumnsQueury().contains(column)) {
addColumn(column, dataType);
}
}
}
}
public void clearCache() {
clearCacheBasic();
}
public void clearCacheBasic() {
columns.clear();
columns.addAll(getColumnsQueury());
uuids.clear();
uuids.addAll(getUuidsQuery());
}
public void close() {
mysql.disconnect();
}
public boolean containsKeyQuery(String index) {
String sqlStr = "SELECT uuid FROM " + getName() + ";";
try (Connection conn = mysql.getConnectionManager().getConnection();
PreparedStatement sql = conn.prepareStatement(sqlStr)) {
ResultSet rs = sql.executeQuery();
/*
* Query query = new Query(mysql, sql); ResultSet rs = query.executeQuery();
*/
while (rs.next()) {
if (rs.getString("uuid").equals(index)) {
rs.close();
return true;
}
}
rs.close();
} catch (SQLException ex) {
ex.printStackTrace();
}
return false;
}
public List<String> getColumns() {
if (columns == null || columns.size() == 0) {
loadData();
}
return columns;
}
public ArrayList<String> getColumnsQueury() {
ArrayList<String> columns = new ArrayList<String>();
try (Connection conn = mysql.getConnectionManager().getConnection();
PreparedStatement sql = conn.prepareStatement("SELECT * FROM " + getName() + ";")) {
ResultSet rs = sql.executeQuery();
/*
* Query query = new Query(mysql, "SELECT * FROM " + getName() + ";"); ResultSet
* rs = query.executeQuery();
*/
ResultSetMetaData metadata = rs.getMetaData();
int columnCount = 0;
if (metadata != null) {
columnCount = metadata.getColumnCount();
for (int i = 1; i <= columnCount; i++) {
String columnName = metadata.getColumnName(i);
columns.add(columnName);
}
rs.close();
return columns;
}
rs.close();
} catch (Exception e) {
e.printStackTrace();
}
return columns;
}
public ArrayList<Column> getExactQuery(Column column) {
ArrayList<Column> result = new ArrayList<>();
String query = "SELECT * FROM " + getName() + " WHERE `" + column.getName() + "`='"
+ column.getValue().toString() + "';";
try (Connection conn = mysql.getConnectionManager().getConnection();
PreparedStatement sql = conn.prepareStatement(query)) {
ResultSet rs = sql.executeQuery();
/*
* Query sql = new Query(mysql, query); sql.setParameter(1,
* column.getValue().toString()); ResultSet rs = sql.executeQuery();
*/
if (rs.next()) {
for (int i = 1; i <= rs.getMetaData().getColumnCount(); i++) {
String columnName = rs.getMetaData().getColumnLabel(i);
Column rCol = null;
if (intColumns.contains(columnName)) {
rCol = new Column(columnName, DataType.INTEGER);
} else {
rCol = new Column(columnName, DataType.STRING);
}
// System.out.println(i + " " +
// rs.getMetaData().getColumnLabel(i));
rCol.setValue(rs.getString(i));
// System.out.println(rCol.getValue());
result.add(rCol);
}
}
rs.close();
return result;
} catch (SQLException e) {
e.printStackTrace();
} catch (ArrayIndexOutOfBoundsException e) {
}
for (String col : getColumns()) {
result.add(new Column(col, DataType.STRING));
}
return result;
}
public String getName() {
return name;
}
public ArrayList<String> getNamesQuery() {
ArrayList<String> uuids = new ArrayList<String>();
checkColumn("PlayerName", DataType.STRING);
ArrayList<Column> rows = getRowsNameQuery();
if (rows != null) {
for (Column c : rows) {
uuids.add((String) c.getValue());
}
}
return uuids;
}
public ArrayList<Column> getRowsNameQuery() {
ArrayList<Column> result = new ArrayList<Column>();
String sqlStr = "SELECT PlayerName FROM " + getName() + ";";
try (Connection conn = mysql.getConnectionManager().getConnection();
PreparedStatement sql = conn.prepareStatement(sqlStr)) {
ResultSet rs = sql.executeQuery();
/*
* Query query = new Query(mysql, sql); ResultSet rs = query.executeQuery();
*/
while (rs.next()) {
Column rCol = new Column("PlayerName", rs.getString("PlayerName"), DataType.STRING);
result.add(rCol);
}
sql.close();
conn.close();
} catch (SQLException e) {
}
return result;
}
public ArrayList<Column> getRowsQuery() {
ArrayList<Column> result = new ArrayList<Column>();
String sqlStr = "SELECT uuid FROM " + getName() + ";";
try (Connection conn = mysql.getConnectionManager().getConnection();
PreparedStatement sql = conn.prepareStatement(sqlStr)) {
ResultSet rs = sql.executeQuery();
/*
* Query query = new Query(mysql, sql); ResultSet rs = query.executeQuery();
*/
while (rs.next()) {
Column rCol = new Column("uuid", rs.getString("uuid"), DataType.STRING);
result.add(rCol);
}
rs.close();
} catch (SQLException e) {
return null;
}
return result;
}
public String getUUID(String playerName) {
String query = "SELECT uuid FROM " + getName() + " WHERE " + "PlayerName" + "='" + playerName + "';";
try (Connection conn = mysql.getConnectionManager().getConnection();
PreparedStatement sql = conn.prepareStatement(query)) {
ResultSet rs = sql.executeQuery();
/*
* Query sql = new Query(mysql, query); ResultSet rs = sql.executeQuery();
*/
if (rs.next()) {
String uuid = rs.getString("uuid");
if (uuid != null && !uuid.isEmpty()) {
rs.close();
return uuid;
}
}
rs.close();
} catch (SQLException e) {
e.printStackTrace();
} catch (ArrayIndexOutOfBoundsException e) {
}
return null;
}
public Set<String> getUuids() {
if (uuids == null || uuids.size() == 0) {
uuids.clear();
uuids.addAll(getUuidsQuery());
return uuids;
}
return uuids;
}
public ArrayList<String> getUuidsQuery() {
ArrayList<String> uuids = new ArrayList<String>();
ArrayList<Column> rows = getRowsQuery();
for (Column c : rows) {
uuids.add((String) c.getValue());
}
return uuids;
}
public void insert(String index, String column, Object value, DataType dataType) {
insertQuery(index, Arrays.asList(new Column(column, value, dataType)));
}
public void insertQuery(String index, List<Column> cols) {
String query = "INSERT " + getName() + " ";
query += "set uuid='" + index + "', ";
for (int i = 0; i < cols.size(); i++) {
Column col = cols.get(i);
if (i == cols.size() - 1) {
query += col.getName() + "='" + col.getValue().toString() + "';";
} else {
query += col.getName() + "='" + col.getValue().toString() + "', ";
}
}
try {
uuids.add(index);
new Query(mysql, query).executeUpdateAsync();
} catch (SQLException e) {
e.printStackTrace();
}
}
public boolean isIntColumn(String key) {
return intColumns.contains(key);
}
public void loadData() {
columns = getColumnsQueury();
}
public void update(String index, List<Column> cols, boolean queue) {
for (Column col : cols) {
checkColumn(col.getName(), col.getDataType());
}
if (getUuids().contains(index)) {
synchronized (object2) {
String query = "UPDATE " + getName() + " SET ";
for (int i = 0; i < cols.size(); i++) {
Column col = cols.get(i);
if (i == cols.size() - 1) {
if (col.getDataType().equals(DataType.STRING)) {
query += col.getName() + "='" + col.getValue().toString() + "';";
} else {
query += col.getName() + "=" + col.getValue().toString() + ";";
}
} else {
if (col.getDataType().equals(DataType.STRING)) {
query += col.getName() + "='" + col.getValue().toString() + "', ";
} else {
query += col.getName() + "=" + col.getValue().toString() + ", ";
}
}
}
query += " WHERE `uuid`=";
query += "'" + index + "';";
try {
Query q = new Query(mysql, query);
q.executeUpdateAsync();
} catch (SQLException e) {
e.printStackTrace();
}
}
} else {
insertQuery(index, cols);
}
}
public void update(String index, String column, Object value, DataType dataType) {
checkColumn(column, dataType);
if (getUuids().contains(index)) {
synchronized (object2) {
String query = "UPDATE " + getName() + " SET ";
if (dataType == DataType.STRING) {
query += column + "='" + value.toString() + "'";
} else {
query += column + "=" + value;
}
query += " WHERE `uuid`=";
query += "'" + index + "';";
try {
Query q = new Query(mysql, query);
q.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
}
}
} else {
insert(index, column, value, dataType);
}
}
}
@@ -0,0 +1,7 @@
package com.bencodez.votingplugin.bungee;
public class BungeeVersion {
public static int getPluginMessageVersion() {
return 1;
}
}
@@ -0,0 +1,107 @@
package com.bencodez.votingplugin.bungee;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.util.Collection;
import java.util.List;
import lombok.Getter;
import net.md_5.bungee.config.Configuration;
import net.md_5.bungee.config.ConfigurationProvider;
import net.md_5.bungee.config.YamlConfiguration;
public class Config {
private VotingPluginBungee bungee;
@Getter
private Configuration data;
public Config(VotingPluginBungee bungee) {
this.bungee = bungee;
}
public List<String> getBlockedServers() {
return getData().getStringList("BlockedServers");
}
public boolean getBroadcast() {
return getData().getBoolean("Broadcast", false);
}
public boolean getWaitForUserOnline() {
return getData().getBoolean("WaitForUserOnline", false);
}
public boolean getBungeeManageTotals() {
return getData().getBoolean("BungeeManageTotals", true);
}
public boolean getAllowUnJoined() {
return getData().getBoolean("AllowUnJoined", false);
}
public String getBungeeHost() {
return getData().getString("BungeeServer.Host", "");
}
public String getBungeeMethod() {
return getData().getString("BungeeMethod", "SOCKETS");
}
public int getBungeePort() {
return getData().getInt("BungeeServer.Port", 1297);
}
public boolean getDebug() {
return getData().getBoolean("Debug", false);
}
public String getFallBack() {
return getData().getString("FallBackServer", "");
}
public boolean getSendVotesToAllServers() {
return getData().getBoolean("SendVotesToAllServers");
}
public Configuration getSpigotServerConfiguration(String s) {
return getData().getSection("SpigotServers." + s);
}
public Collection<String> getSpigotServers() {
return getData().getSection("SpigotServers").getKeys();
}
public void load() {
if (!bungee.getDataFolder().exists()) {
bungee.getDataFolder().mkdir();
}
File file = new File(bungee.getDataFolder(), "bungeeconfig.yml");
if (!file.exists()) {
try (InputStream in = bungee.getResourceAsStream("bungeeconfig.yml")) {
Files.copy(in, file.toPath());
} catch (IOException e) {
e.printStackTrace();
}
}
try {
data = ConfigurationProvider.getProvider(YamlConfiguration.class)
.load(new File(bungee.getDataFolder(), "bungeeconfig.yml"));
} catch (IOException e) {
e.printStackTrace();
}
}
public void save() {
try {
ConfigurationProvider.getProvider(YamlConfiguration.class).save(data,
new File(bungee.getDataFolder(), "bungeeconfig.yml"));
} catch (IOException e) {
e.printStackTrace();
}
}
}
@@ -0,0 +1,94 @@
package com.bencodez.votingplugin.bungee;
import java.io.File;
import java.io.IOException;
import lombok.Getter;
import net.md_5.bungee.api.connection.ProxiedPlayer;
import net.md_5.bungee.config.Configuration;
import net.md_5.bungee.config.ConfigurationProvider;
import net.md_5.bungee.config.YamlConfiguration;
public class NonVotedPlayersCache {
private VotingPluginBungee bungee;
@Getter
private Configuration data;
public NonVotedPlayersCache(VotingPluginBungee bungee) {
this.bungee = bungee;
}
public void addPlayer(ProxiedPlayer proxiedPlayer) {
if (!bungee.getMysql().containsKeyQuery(proxiedPlayer.getUniqueId().toString())) {
addPlayer(proxiedPlayer.getUniqueId().toString(), proxiedPlayer.getName());
}
}
private void addPlayer(String uuid, String playerName) {
getData().set("NonVotedPlayers." + playerName + ".UUID", uuid);
getData().set("NonVotedPlayers." + playerName + ".LastTime", System.currentTimeMillis());
}
public String playerExists(String playerName) {
if (getData().getSection("NonVotedPlayers").getKeys().contains(playerName)) {
return getData().getString("NonVotedPlayers." + playerName + ".UUID", "");
}
return "";
}
private void remove(String player) {
bungee.debug("Removing nonvotedplayer: " + player);
getData().set("NonVotedPlayers." + player, null);
}
public void check() {
for (String player : getData().getSection("NonVotedPlayers").getKeys()) {
long time = getData().getLong("NonVotedPlayers." + player + ".LastTime", 0);
if ((System.currentTimeMillis() - time) > 1000 * 60 * 60 * 24 * 5) {
remove(player);
} else {
String uuid = getData().getString("NonVotedPlayers." + player + ".UUID", "");
if (!uuid.isEmpty()) {
if (bungee.getMysql().containsKeyQuery(uuid)) {
remove(player);
}
} else {
remove(player);
}
}
}
save();
}
public void load() {
if (!bungee.getDataFolder().exists()) {
bungee.getDataFolder().mkdir();
}
File file = new File(bungee.getDataFolder(), "nonvotedplayerscache.yml");
if (!file.exists()) {
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
try {
data = ConfigurationProvider.getProvider(YamlConfiguration.class)
.load(new File(bungee.getDataFolder(), "nonvotedplayerscache.yml"));
} catch (IOException e) {
e.printStackTrace();
}
}
public void save() {
try {
ConfigurationProvider.getProvider(YamlConfiguration.class).save(data,
new File(bungee.getDataFolder(), "nonvotedplayerscache.yml"));
} catch (IOException e) {
e.printStackTrace();
}
}
}
@@ -0,0 +1,34 @@
package com.bencodez.votingplugin.bungee;
import lombok.Getter;
public class OfflineBungeeVote {
@Getter
private String playerName;
@Getter
private boolean realVote;
@Getter
private String service;
@Getter
private String text;
@Getter
private long time;
@Getter
private String uuid;
public OfflineBungeeVote(String playerName, String uuid, String service, long time, boolean realVote, String text) {
this.playerName = playerName;
this.uuid = uuid;
this.service = service;
this.time = time;
this.realVote = realVote;
this.text = text;
}
@Override
public String toString() {
return "VoteCache:" + playerName + "/" + uuid + "/" + service + "/" + time + "/" + realVote + "/" + text;
}
}
@@ -0,0 +1,104 @@
package com.bencodez.votingplugin.bungee;
import java.io.File;
import java.io.IOException;
import java.util.Collection;
import lombok.Getter;
import net.md_5.bungee.config.Configuration;
import net.md_5.bungee.config.ConfigurationProvider;
import net.md_5.bungee.config.YamlConfiguration;
public class VoteCache {
private VotingPluginBungee bungee;
@Getter
private Configuration data;
public VoteCache(VotingPluginBungee bungee) {
this.bungee = bungee;
}
public void addVote(String server, int num, OfflineBungeeVote voteData) {
Configuration section = getData().getSection("VoteCache." + server + "." + num);
section.set("Name", voteData.getPlayerName());
section.set("Service", voteData.getService());
section.set("UUID", voteData.getUuid());
section.set("Time", voteData.getTime());
section.set("Real", voteData.isRealVote());
section.set("Text", voteData.getText());
save();
}
public void addVoteOnline(String player, int num, OfflineBungeeVote voteData) {
Configuration section = getData().getSection("OnlineCache." + player + "." + num);
section.set("Name", voteData.getPlayerName());
section.set("Service", voteData.getService());
section.set("UUID", voteData.getUuid());
section.set("Time", voteData.getTime());
section.set("Real", voteData.isRealVote());
section.set("Text", voteData.getText());
save();
}
public void clearData() {
getData().set("VoteCache", null);
getData().set("OnlineCache", null);
save();
}
public Collection<String> getOnlineVotes(String name) {
return getData().getSection("OnlineCache." + name).getKeys();
}
public Configuration getOnlineVotes(String name, String num) {
return getData().getSection("OnlineCache." + name + "." + num);
}
public Collection<String> getPlayers() {
return getData().getSection("OnlineCache").getKeys();
}
public Collection<String> getServers() {
return getData().getSection("VoteCache").getKeys();
}
public Collection<String> getServerVotes(String server) {
return getData().getSection("VoteCache." + server).getKeys();
}
public Configuration getServerVotes(String server, String num) {
return getData().getSection("VoteCache." + server + "." + num);
}
public void load() {
if (!bungee.getDataFolder().exists()) {
bungee.getDataFolder().mkdir();
}
File file = new File(bungee.getDataFolder(), "votecache.yml");
if (!file.exists()) {
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
try {
data = ConfigurationProvider.getProvider(YamlConfiguration.class)
.load(new File(bungee.getDataFolder(), "votecache.yml"));
} catch (IOException e) {
e.printStackTrace();
}
}
public void save() {
try {
ConfigurationProvider.getProvider(YamlConfiguration.class).save(data,
new File(bungee.getDataFolder(), "votecache.yml"));
} catch (IOException e) {
e.printStackTrace();
}
}
}
@@ -0,0 +1,23 @@
package com.bencodez.votingplugin.bungee;
import com.vexsoftware.votifier.bungee.events.VotifierEvent;
import com.vexsoftware.votifier.model.Vote;
import net.md_5.bungee.event.EventHandler;
public class VoteEventBungee implements net.md_5.bungee.api.plugin.Listener {
private VotingPluginBungee plugin;
public VoteEventBungee(VotingPluginBungee plugin) {
this.plugin = plugin;
}
@EventHandler
public void onVote(VotifierEvent event) {
Vote vote = event.getVote();
plugin.getLogger().info("Vote received " + vote.getUsername() + " from service site " + vote.getServiceName());
plugin.vote(vote.getUsername(), vote.getServiceName(), true);
}
}
@@ -0,0 +1,720 @@
package com.bencodez.votingplugin.bungee;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map.Entry;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import com.bencodez.advancedcore.api.misc.ArrayUtils;
import com.bencodez.advancedcore.api.misc.encryption.EncryptionHandler;
import com.bencodez.advancedcore.api.user.userstorage.sql.Column;
import com.bencodez.advancedcore.api.user.userstorage.sql.DataType;
import com.bencodez.advancedcore.bungeeapi.sockets.ClientHandler;
import com.bencodez.advancedcore.bungeeapi.sockets.SocketHandler;
import com.bencodez.advancedcore.bungeeapi.sockets.SocketReceiver;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import lombok.Getter;
import net.md_5.bungee.api.CommandSender;
import net.md_5.bungee.api.config.ServerInfo;
import net.md_5.bungee.api.connection.ProxiedPlayer;
import net.md_5.bungee.api.connection.Server;
import net.md_5.bungee.api.event.PluginMessageEvent;
import net.md_5.bungee.api.event.PostLoginEvent;
import net.md_5.bungee.api.event.ServerConnectedEvent;
import net.md_5.bungee.api.plugin.Plugin;
import net.md_5.bungee.config.Configuration;
import net.md_5.bungee.event.EventHandler;
public class VotingPluginBungee extends Plugin {
private HashMap<String, ArrayList<OfflineBungeeVote>> cachedOnlineVotes = new HashMap<String, ArrayList<OfflineBungeeVote>>();
private HashMap<String, ArrayList<OfflineBungeeVote>> cachedVotes = new HashMap<String, ArrayList<OfflineBungeeVote>>();
private HashMap<String, ClientHandler> clientHandles;
@Getter
private Config config;
private EncryptionHandler encryptionHandler;
@Getter
private BungeeMethod method;
@Getter
private BungeeMySQL mysql;
private SocketHandler socketHandler;
private VoteCache voteCacheFile;
private NonVotedPlayersCache nonVotedPlayersCache;
public void checkCachedVotes(String server) {
if (getProxy().getServerInfo(server) != null) {
if (!getProxy().getServerInfo(server).getPlayers().isEmpty()) {
if (cachedVotes.containsKey(server) && !config.getBlockedServers().contains(server)) {
ArrayList<OfflineBungeeVote> c = cachedVotes.get(server);
ArrayList<OfflineBungeeVote> newSet = new ArrayList<OfflineBungeeVote>();
if (!c.isEmpty()) {
for (OfflineBungeeVote cache : c) {
boolean toSend = true;
if (getConfig().getWaitForUserOnline()) {
ProxiedPlayer p = getProxy().getPlayer(UUID.fromString(cache.getUuid()));
if (p == null || !p.isConnected()) {
toSend = false;
} else if (p != null && p.isConnected()
&& !p.getServer().getInfo().getName().equals(server)) {
toSend = false;
}
}
if (toSend) {
sendPluginMessageServer(server, "Vote", cache.getPlayerName(), cache.getUuid(),
cache.getService(), "" + cache.getTime(), Boolean.FALSE.toString(),
"" + cache.isRealVote(), cache.getText(),
"" + getConfig().getBungeeManageTotals(),
"" + BungeeVersion.getPluginMessageVersion());
} else {
debug("Not sending vote because user isn't on server " + server + ": "
+ cache.toString());
newSet.add(cache);
}
}
cachedVotes.put(server, newSet);
}
}
}
}
}
public void checkOnlineVotes(ProxiedPlayer player, String uuid, String server) {
if (player != null && player.isConnected() && cachedOnlineVotes.containsKey(uuid)) {
ArrayList<OfflineBungeeVote> c = cachedOnlineVotes.get(uuid);
if (!c.isEmpty()) {
if (server == null) {
server = getProxy().getPlayer(UUID.fromString(uuid)).getServer().getInfo().getName();
}
if (!config.getBlockedServers().contains(server)) {
for (OfflineBungeeVote cache : c) {
sendPluginMessageServer(server, "VoteOnline", cache.getPlayerName(), cache.getUuid(),
cache.getService(), "" + cache.getTime(), Boolean.FALSE.toString(),
"" + cache.isRealVote(), cache.getText(), "" + getConfig().getBungeeManageTotals(),
"" + BungeeVersion.getPluginMessageVersion());
}
cachedOnlineVotes.put(uuid, new ArrayList<OfflineBungeeVote>());
}
}
}
}
public void debug(String msg) {
if (config.getDebug()) {
getLogger().info("Debug: " + msg);
}
}
public UUID fetchUUID(String playerName) throws Exception {
// Get response from Mojang API
URL url = new URL("https://api.mojang.com/users/profiles/minecraft/" + playerName);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.connect();
if (connection.getResponseCode() == 400) {
getProxy().getLogger().info("There is no player with the name \"" + playerName + "\"!");
return null;
}
InputStream inputStream = connection.getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
// Parse JSON response and get UUID
JsonElement element = new JsonParser().parse(bufferedReader);
JsonObject object = element.getAsJsonObject();
String uuidAsString = object.get("id").getAsString();
// Return UUID
return parseUUIDFromString(uuidAsString);
}
public String getProperName(String uuid, String currentName) {
ProxiedPlayer p = getProxy().getPlayer(UUID.fromString(uuid));
if (p != null && p.isConnected()) {
return p.getName();
}
return currentName;
}
public String getUUID(String playerName) {
ProxiedPlayer p = getProxy().getPlayer(playerName);
if (p != null && p.isConnected()) {
return p.getUniqueId().toString();
}
if (mysql != null) {
String str = mysql.getUUID(playerName);
if (str != null) {
return str;
}
}
if (nonVotedPlayersCache != null) {
return nonVotedPlayersCache.playerExists(playerName);
}
return "";
}
private int getValue(ArrayList<Column> cols, String column) {
for (Column d : cols) {
if (d.getName().equalsIgnoreCase(column)) {
Object value = d.getValue();
int num = 0;
if (value instanceof Integer) {
try {
num = (int) value;
} catch (ClassCastException | NullPointerException ex) {
}
} else if (value instanceof String) {
try {
num = Integer.parseInt((String) value);
} catch (Exception e) {
}
}
return num;
}
}
return 0;
}
private int mysqlUpdate(ArrayList<Column> cols, String uuid, String column, int toAdd) {
int num = getValue(cols, column) + toAdd;
debug("Setting " + column + " to " + num + " for " + uuid);
mysql.update(uuid, column, num, DataType.INTEGER);
return num;
}
@Override
public void onDisable() {
if (method.equals(BungeeMethod.PLUGINMESSAGING)) {
for (Entry<String, ArrayList<OfflineBungeeVote>> entry : cachedVotes.entrySet()) {
String server = entry.getKey();
int num = 0;
for (OfflineBungeeVote voteData : entry.getValue()) {
voteCacheFile.addVote(server, num, voteData);
num++;
}
}
for (Entry<String, ArrayList<OfflineBungeeVote>> entry : cachedOnlineVotes.entrySet()) {
String name = entry.getKey();
int num = 0;
for (OfflineBungeeVote voteData : entry.getValue()) {
voteCacheFile.addVoteOnline(name, num, voteData);
num++;
}
}
nonVotedPlayersCache.save();
}
}
private boolean votifierEnabled = true;
@Override
public void onEnable() {
try {
Class.forName("com.vexsoftware.votifier.bungee.events.VotifierEvent");
} catch (ClassNotFoundException e) {
votifierEnabled = false;
getLogger().warning("Votifier event not found, not loading votifier event");
}
if (votifierEnabled) {
try {
getProxy().getPluginManager().registerListener(this, new VoteEventBungee(this));
} catch (Exception e) {
}
}
config = new Config(this);
config.load();
try {
mysql = new BungeeMySQL("VotingPlugin_Users", config.getData());
// column types
getMysql().alterColumnType("TopVoterIgnore", "VARCHAR(5)");
getMysql().alterColumnType("CheckWorld", "VARCHAR(5)");
getMysql().alterColumnType("Reminded", "VARCHAR(5)");
getMysql().alterColumnType("DisableBroadcast", "VARCHAR(5)");
getMysql().alterColumnType("LastOnline", "VARCHAR(20)");
getMysql().alterColumnType("PlayerName", "VARCHAR(30)");
getMysql().alterColumnType("DailyTotal", "INT DEFAULT '0'");
getMysql().alterColumnType("WeeklyTotal", "INT DEFAULT '0'");
getMysql().alterColumnType("DayVoteStreak", "INT DEFAULT '0'");
getMysql().alterColumnType("BestDayVoteStreak", "INT DEFAULT '0'");
getMysql().alterColumnType("WeekVoteStreak", "INT DEFAULT '0'");
getMysql().alterColumnType("BestWeekVoteStreak", "INT DEFAULT '0'");
getMysql().alterColumnType("VotePartyVotes", "INT DEFAULT '0'");
getMysql().alterColumnType("MonthVoteStreak", "INT DEFAULT '0'");
getMysql().alterColumnType("Points", "INT DEFAULT '0'");
getMysql().alterColumnType("HighestDailyTotal", "INT DEFAULT '0'");
getMysql().alterColumnType("AllTimeTotal", "INT DEFAULT '0'");
getMysql().alterColumnType("HighestMonthlyTotal", "INT DEFAULT '0'");
getMysql().alterColumnType("MilestoneCount", "INT DEFAULT '0'");
getMysql().alterColumnType("MonthTotal", "INT DEFAULT '0'");
getMysql().alterColumnType("HighestWeeklyTotal", "INT DEFAULT '0'");
getMysql().alterColumnType("LastMonthTotal", "INT DEFAULT '0'");
getMysql().alterColumnType("OfflineRewards", "MEDIUMTEXT");
getMysql().alterColumnType("DayVoteStreakLastUpdate", "MEDIUMTEXT");
} catch (Exception e) {
e.printStackTrace();
}
getProxy().getPluginManager().registerCommand(this, new VotingPluginBungeeCommand(this));
method = BungeeMethod.getByName(config.getBungeeMethod());
if (method == null) {
method = BungeeMethod.PLUGINMESSAGING;
}
this.getProxy().registerChannel("vp:vp");
if (method.equals(BungeeMethod.MYSQL)) {
// this.getProxy().registerChannel("vp:vp");
} else if (method.equals(BungeeMethod.PLUGINMESSAGING)) {
voteCacheFile = new VoteCache(this);
voteCacheFile.load();
nonVotedPlayersCache = new NonVotedPlayersCache(this);
nonVotedPlayersCache.load();
try {
for (String server : voteCacheFile.getServers()) {
ArrayList<OfflineBungeeVote> vote = new ArrayList<OfflineBungeeVote>();
for (String num : voteCacheFile.getServerVotes(server)) {
Configuration data = voteCacheFile.getServerVotes(server, num);
vote.add(new OfflineBungeeVote(data.getString("Name"), data.getString("UUID"),
data.getString("Service"), data.getLong("Time"), data.getBoolean("Real"),
data.getString("Text")));
}
cachedVotes.put(server, vote);
}
} catch (Exception e) {
e.printStackTrace();
}
try {
for (String player : voteCacheFile.getPlayers()) {
ArrayList<OfflineBungeeVote> vote = new ArrayList<OfflineBungeeVote>();
for (String num : voteCacheFile.getServerVotes(player)) {
Configuration data = voteCacheFile.getOnlineVotes(player, num);
vote.add(new OfflineBungeeVote(data.getString("Name"), data.getString("UUID"),
data.getString("Service"), data.getLong("Time"), data.getBoolean("Real"),
data.getString("Text")));
}
cachedOnlineVotes.put(player, vote);
}
} catch (Exception e) {
e.printStackTrace();
}
voteCacheFile.clearData();
getProxy().getScheduler().schedule(this, new Runnable() {
@Override
public void run() {
for (String server : cachedVotes.keySet()) {
checkCachedVotes(server);
}
for (String player : cachedOnlineVotes.keySet()) {
checkOnlineVotes(getProxy().getPlayer(UUID.fromString(player)), player, null);
}
}
}, 15l, 30l, TimeUnit.SECONDS);
getProxy().getScheduler().schedule(this, new Runnable() {
@Override
public void run() {
if (nonVotedPlayersCache != null) {
debug("Checking nonvotedplayers.yml...");
nonVotedPlayersCache.check();
}
}
}, 1l, 60l, TimeUnit.MINUTES);
} else if (method.equals(BungeeMethod.SOCKETS)) {
encryptionHandler = new EncryptionHandler(new File(getDataFolder(), "secretkey.key"));
socketHandler = new SocketHandler(getDescription().getVersion(), config.getBungeeHost(),
config.getBungeePort(), encryptionHandler, config.getDebug());
socketHandler.add(new SocketReceiver() {
@Override
public void onReceive(String[] data) {
if (data.length > 1) {
if (data.length > 2) {
if (data[0].equalsIgnoreCase("Broadcast")) {
sendServerMessage(data);
}
}
}
}
});
socketHandler.add(new SocketReceiver() {
@Override
public void onReceive(String[] data) {
if (data.length > 1) {
if (data[0].equalsIgnoreCase("StatusOkay")) {
String server = data[1];
getLogger().info("Voting communicaton okay with " + server);
}
}
}
});
clientHandles = new HashMap<String, ClientHandler>();
List<String> l = config.getBlockedServers();
for (String s : config.getSpigotServers()) {
if (!l.contains(s)) {
Configuration d = config.getSpigotServerConfiguration(s);
clientHandles.put(s, new ClientHandler(d.getString("Host", ""), d.getInt("Port", 1298),
encryptionHandler, config.getDebug()));
}
}
}
BStatsMetricsBungee metrics = new BStatsMetricsBungee(this, 9453);
metrics.addCustomChart(
new BStatsMetricsBungee.SimplePie("bungee_method", () -> getConfig().getBungeeMethod().toString()));
metrics.addCustomChart(new BStatsMetricsBungee.SimplePie("sendtoallservers",
() -> "" + getConfig().getSendVotesToAllServers()));
getLogger().info("VotingPlugin loaded, using method: " + method.toString());
}
@EventHandler
public void onPluginMessage(PluginMessageEvent ev) {
if (!ev.getTag().equals("vp:vp".toLowerCase())) {
return;
}
ev.setCancelled(true);
if (!(ev.getSender() instanceof Server))
return;
ByteArrayInputStream instream = new ByteArrayInputStream(ev.getData());
DataInputStream in = new DataInputStream(instream);
try {
ByteArrayOutputStream outstream = new ByteArrayOutputStream();
DataOutputStream out = new DataOutputStream(outstream);
String subchannel = in.readUTF();
int size = in.readInt();
// check for status message returns
if (subchannel.equalsIgnoreCase("statusokay")) {
String server = in.readUTF();
getLogger().info("Status okay for " + server);
return;
} else if (subchannel.equalsIgnoreCase("login")) {
String player = in.readUTF();
ProxiedPlayer p = getProxy().getPlayer(player);
String server = p.getServer().getInfo().getName();
checkCachedVotes(server);
checkOnlineVotes(p, p.getUniqueId().toString(), server);
return;
} else {
// reforward message
out.writeUTF(subchannel);
out.writeInt(size);
for (int i = 0; i < size; i++) {
out.writeUTF(in.readUTF());
}
for (String send : getProxy().getServers().keySet()) {
if (getProxy().getServers().get(send).getPlayers().size() > 0) {
getProxy().getServers().get(send).sendData("vp:vp".toLowerCase(), outstream.toByteArray());
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
@EventHandler
public void onLogin(PostLoginEvent event) {
if (nonVotedPlayersCache != null) {
nonVotedPlayersCache.addPlayer(event.getPlayer());
}
}
@EventHandler
public void onServerConnected(ServerConnectedEvent event) {
final String server = event.getServer().getInfo().getName();
final String uuid = event.getPlayer().getUniqueId().toString();
getProxy().getScheduler().schedule(this, new Runnable() {
@Override
public void run() {
checkCachedVotes(server);
checkOnlineVotes(event.getPlayer(), uuid, server);
}
}, 2, TimeUnit.SECONDS);
}
private UUID parseUUIDFromString(String uuidAsString) {
String[] parts = { "0x" + uuidAsString.substring(0, 8), "0x" + uuidAsString.substring(8, 12),
"0x" + uuidAsString.substring(12, 16), "0x" + uuidAsString.substring(16, 20),
"0x" + uuidAsString.substring(20, 32) };
long mostSigBits = Long.decode(parts[0]).longValue();
mostSigBits <<= 16;
mostSigBits |= Long.decode(parts[1]).longValue();
mostSigBits <<= 16;
mostSigBits |= Long.decode(parts[2]).longValue();
long leastSigBits = Long.decode(parts[3]).longValue();
leastSigBits <<= 48;
leastSigBits |= Long.decode(parts[4]).longValue();
return new UUID(mostSigBits, leastSigBits);
}
public void reload() {
config.load();
}
public void sendPluginMessageServer(String server, String channel, String... messageData) {
ByteArrayOutputStream byteOutStream = new ByteArrayOutputStream();
DataOutputStream out = new DataOutputStream(byteOutStream);
try {
out.writeUTF(channel);
out.writeInt(messageData.length);
for (String message : messageData) {
out.writeUTF(message);
}
if (getProxy().getServers().get(server).getPlayers().size() > 0) {
getProxy().getServers().get(server).sendData("vp:vp".toLowerCase(), byteOutStream.toByteArray(), false);
}
out.close();
} catch (Exception e) {
e.printStackTrace();
}
debug("Sending plugin message " + server + " " + channel + " "
+ ArrayUtils.getInstance().makeStringList(ArrayUtils.getInstance().convert(messageData)));
}
public void sendServerMessage(String... messageData) {
for (ClientHandler h : clientHandles.values()) {
h.sendMessage(messageData);
}
}
public void sendServerMessageServer(String server, String... messageData) {
if (clientHandles.containsKey(server)) {
clientHandles.get(server).sendMessage(messageData);
}
}
public void sendSocketVote(String name, String service, BungeeMessageData text) {
String uuid = getUUID(name);
if (config.getSendVotesToAllServers()) {
sendServerMessage("bungeevote", uuid, name, service, text.toString(),
"" + getConfig().getBungeeManageTotals());
if (config.getBroadcast()) {
sendServerMessage("BungeeBroadcast", service, uuid, name);
}
} else {
// online server only
ProxiedPlayer p = getProxy().getPlayer(name);
String server = "";
if (p != null && p.isConnected()) {
server = p.getServer().getInfo().getName();
} else {
server = config.getFallBack();
}
if (config.getBlockedServers().contains(server)) {
server = config.getFallBack();
}
sendServerMessageServer(server, "bungeevoteonline", uuid, name, service, text.toString(),
"" + getConfig().getBungeeManageTotals());
if (config.getBroadcast()) {
sendServerMessage("BungeeBroadcast", service, uuid, name);
}
sendServerMessage("BungeeUpdate");
}
}
public void status(CommandSender sender) {
if (method.equals(BungeeMethod.SOCKETS)) {
sendServerMessage("status");
} else if (method.equals(BungeeMethod.PLUGINMESSAGING)) {
for (String s : getProxy().getServers().keySet()) {
if (!config.getBlockedServers().contains(s)) {
ServerInfo info = getProxy().getServerInfo(s);
if (info.getPlayers().isEmpty()) {
getLogger().info("No players on server " + s + " to send test status message");
} else {
// send
getLogger().info("Sending request for status message on " + s);
sendPluginMessageServer(s, "Status", s);
}
} else {
getLogger().info("Ignoring blocked server " + s);
}
}
}
}
public void vote(String player, String service, boolean realVote) {
try {
if (player == null || player.isEmpty()) {
getLogger().info("No name from vote on " + service);
return;
}
String uuid = getUUID(player);
if (uuid.isEmpty()) {
if (config.getAllowUnJoined()) {
UUID u = null;
try {
u = fetchUUID(player);
} catch (Exception e) {
if (getConfig().getDebug()) {
e.printStackTrace();
}
}
if (u == null) {
debug("Failed to get uuid for " + player);
return;
}
uuid = u.toString();
} else {
getLogger().info("Ignoring vote from " + player);
return;
}
}
player = getProperName(uuid, player);
BungeeMessageData text = null;
if (getConfig().getBungeeManageTotals()) {
if (!mysql.getUuids().contains(uuid)) {
mysql.update(uuid, "PlayerName", player, DataType.STRING);
}
ArrayList<Column> data = mysql.getExactQuery(new Column("uuid", uuid, DataType.STRING));
text = new BungeeMessageData(mysqlUpdate(data, uuid, "AllTimeTotal", 1),
mysqlUpdate(data, uuid, "MonthTotal", 1), mysqlUpdate(data, uuid, "WeeklyTotal", 1),
mysqlUpdate(data, uuid, "DailyTotal", 1), mysqlUpdate(data, uuid, "Points", 1),
mysqlUpdate(data, uuid, "MilestoneCount", 1));
} else {
text = new BungeeMessageData(0, 0, 0, 0, 0, 0);
}
/*
* String text = mysqlUpdate(data, uuid, "AllTimeTotal", 1) + "//" +
* mysqlUpdate(data, uuid, "MonthTotal", 1) + "//" + mysqlUpdate(data, uuid,
* "WeeklyTotal", 1) + "//" + mysqlUpdate(data, uuid, "DailyTotal", 1) + "//" +
* mysqlUpdate(data, uuid, "Points", 1) + "//" + mysqlUpdate(data, uuid,
* "MilestoneCount", 1);
*/
long time = LocalDateTime.now().atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
if (method.equals(BungeeMethod.PLUGINMESSAGING)) {
if (config.getSendVotesToAllServers()) {
for (String s : getProxy().getServers().keySet()) {
if (!config.getBlockedServers().contains(s)) {
ServerInfo info = getProxy().getServerInfo(s);
boolean forceCache = false;
ProxiedPlayer p = getProxy().getPlayer(UUID.fromString(uuid));
if ((p == null || !p.isConnected()) && getConfig().getWaitForUserOnline()) {
forceCache = true;
debug("Forcing vote to cache");
}
if (info.getPlayers().isEmpty() || forceCache) {
// cache
if (!cachedVotes.containsKey(s)) {
cachedVotes.put(s, new ArrayList<OfflineBungeeVote>());
}
ArrayList<OfflineBungeeVote> list = cachedVotes.get(s);
list.add(new OfflineBungeeVote(player, uuid, service, time, realVote, text.toString()));
cachedVotes.put(s, list);
debug("Caching vote for " + player + " on " + service + " for " + s);
} else {
// send
sendPluginMessageServer(s, "Vote", player, uuid, service, "" + time,
Boolean.TRUE.toString(), "" + realVote, text.toString(),
"" + getConfig().getBungeeManageTotals(),
"" + BungeeVersion.getPluginMessageVersion());
}
}
}
} else {
ProxiedPlayer p = getProxy().getPlayer(UUID.fromString(uuid));
if (p != null && p.isConnected()
&& !config.getBlockedServers().contains(p.getServer().getInfo().getName())) {
sendPluginMessageServer(p.getServer().getInfo().getName(), "VoteOnline", player, uuid, service,
"" + time, Boolean.TRUE.toString(), "" + realVote, text.toString(),
"" + getConfig().getBungeeManageTotals(), "" + BungeeVersion.getPluginMessageVersion());
} else {
if (!cachedOnlineVotes.containsKey(uuid)) {
cachedOnlineVotes.put(uuid, new ArrayList<OfflineBungeeVote>());
}
ArrayList<OfflineBungeeVote> list = cachedOnlineVotes.get(uuid);
if (list == null) {
list = new ArrayList<OfflineBungeeVote>();
}
list.add(new OfflineBungeeVote(player, uuid, service, time, realVote, text.toString()));
cachedOnlineVotes.put(uuid, list);
debug("Caching online vote for " + player + " on " + service);
}
}
} else if (method.equals(BungeeMethod.SOCKETS)) {
sendSocketVote(player, service, text);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
@@ -0,0 +1,56 @@
package com.bencodez.votingplugin.bungee;
import net.md_5.bungee.api.CommandSender;
import net.md_5.bungee.api.chat.TextComponent;
import net.md_5.bungee.api.plugin.Command;
public class VotingPluginBungeeCommand extends Command {
private VotingPluginBungee bungee;
public VotingPluginBungeeCommand(VotingPluginBungee bungee) {
super("votingpluginbungee", "votingplugin.admin");
this.bungee = bungee;
}
@Override
public void execute(CommandSender sender, String[] args) {
if (sender.hasPermission("votingplugin.admin")) {
if (args.length > 0) {
if (args[0].equalsIgnoreCase("reload")) {
bungee.reload();
sender.sendMessage(new TextComponent("Reloading VotingPluginBungee"));
}
if (args[0].equalsIgnoreCase("vote")) {
if (args.length >= 2) {
String user = args[1];
String site = args[2];
bungee.vote(user, site, false);
sender.sendMessage(new TextComponent("Sending vote"));
}
}
if (args[0].equalsIgnoreCase("status")) {
if (bungee.getMethod().equals(BungeeMethod.SOCKETS)) {
sender.sendMessage(new TextComponent(
"Checking status, waiting for response, check console, method: sockets"));
bungee.status(sender);
} else if (bungee.getMethod().equals(BungeeMethod.PLUGINMESSAGING)){
sender.sendMessage(new TextComponent(
"Checking status, waiting for response, check console, method: plugin messaging"));
bungee.status(sender);
} else {
sender.sendMessage(new TextComponent("Not using socket/pluginmessage method, command unavailable"));
}
}
if (args[0].equalsIgnoreCase("help")) {
TextComponent[] msg = new TextComponent[3];
msg[0] = new TextComponent("&avotingpluginbungee reload - Reload plugin");
msg[1] = new TextComponent("&avotingpluginbungee vote (player) (servicesite) - Send bungee vote");
msg[2] = new TextComponent("&avotingplugin status - Check socket connection status");
sender.sendMessage(msg);
}
}
} else {
sender.sendMessage(new TextComponent("You do not have permission to do this!"));
}
}
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,44 @@
package com.bencodez.votingplugin.commands.executers;
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import com.bencodez.advancedcore.api.command.CommandHandler;
import com.bencodez.votingplugin.VotingPluginMain;
// TODO: Auto-generated Javadoc
/**
* The Class CommandAdminVote.
*/
public class CommandAdminVote implements CommandExecutor {
private VotingPluginMain plugin;
public CommandAdminVote(VotingPluginMain plugin) {
this.plugin = plugin;
}
/*
* (non-Javadoc)
*
* @see org.bukkit.command.CommandExecutor#onCommand(org.bukkit.command.
* CommandSender , org.bukkit.command.Command, java.lang.String,
* java.lang.String[])
*/
@Override
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
for (CommandHandler commandHandler : plugin.getAdminVoteCommand()) {
if (commandHandler.runCommand(sender, args)) {
return true;
}
}
// invalid command
sender.sendMessage(ChatColor.RED + "No valid arguments, see /adminvote help!");
return true;
}
}
@@ -1,100 +1,100 @@
package com.Ben12345rocks.VotingPlugin.Commands.Executers;
import java.util.ArrayList;
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import com.Ben12345rocks.AdvancedCore.Objects.CommandHandler;
import com.Ben12345rocks.AdvancedCore.Util.Misc.ArrayUtils;
import com.Ben12345rocks.VotingPlugin.Main;
// TODO: Auto-generated Javadoc
/**
* The Class CommandAliases.
*/
public class CommandAliases implements CommandExecutor {
/** The plugin. */
private Main plugin = Main.plugin;
/** The cmd handle. */
private CommandHandler cmdHandle;
private boolean adminCommand;
public CommandAliases(CommandHandler cmdHandle, boolean adminCommand) {
this.cmdHandle = cmdHandle;
this.adminCommand = adminCommand;
}
/*
* (non-Javadoc)
*
* @see org.bukkit.command.CommandExecutor#onCommand(org.bukkit.command.
* CommandSender , org.bukkit.command.Command, java.lang.String,
* java.lang.String[])
*/
@Override
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
ArrayList<String> argsNew = new ArrayList<String>();
argsNew.add(cmdHandle.getArgs()[0]);
for (String arg : args) {
argsNew.add(arg);
}
plugin.debug("Attempting cmd...");
plugin.debug("Inputed args: " + ArrayUtils.getInstance().makeStringList(argsNew));
ArrayList<CommandHandler> handles = new ArrayList<CommandHandler>();
if (adminCommand) {
handles.addAll(plugin.adminVoteCommand);
} else {
handles.addAll(plugin.voteCommand);
}
for (CommandHandler cmdHandle : handles) {
if (cmdHandle.getArgs().length > args.length) {
for (String arg : cmdHandle.getArgs()[0].split("&")) {
if (cmd.getName().equalsIgnoreCase("vote" + arg)
|| cmd.getName().equalsIgnoreCase("adminvote" + arg)) {
argsNew.set(0, arg);
boolean argsMatch = true;
for (int i = 0; i < argsNew.size(); i++) {
if (i < cmdHandle.getArgs().length) {
if (!cmdHandle.argsMatch(argsNew.get(i), i)) {
argsMatch = false;
}
}
}
if (argsMatch) {
if (cmdHandle.runCommand(sender, ArrayUtils.getInstance().convert(argsNew))) {
plugin.debug("cmd found, ran cmd");
return true;
}
}
}
}
}
}
/*
* for (String arg : cmdHandle.getArgs()[0].split("&")) { argsNew.set(0, arg);
* if (cmdHandle.runCommand(sender, Utils.getInstance().convertArray(argsNew)))
* { plugin.debug( "cmd found, ran cmd"); return true; } }
*/
// invalid command
if (adminCommand) {
sender.sendMessage(ChatColor.RED + "No valid arguments, see /adminvote help!");
} else {
sender.sendMessage(ChatColor.RED + "No valid arguments, see /vote help!");
}
return true;
}
}
package com.bencodez.votingplugin.commands.executers;
import java.util.ArrayList;
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import com.bencodez.advancedcore.api.command.CommandHandler;
import com.bencodez.advancedcore.api.misc.ArrayUtils;
import com.bencodez.votingplugin.VotingPluginMain;
// TODO: Auto-generated Javadoc
/**
* The Class CommandAliases.
*/
public class CommandAliases implements CommandExecutor {
private boolean adminCommand;
/** The cmd handle. */
private CommandHandler cmdHandle;
/** The plugin. */
private VotingPluginMain plugin = VotingPluginMain.plugin;
public CommandAliases(CommandHandler cmdHandle, boolean adminCommand) {
this.cmdHandle = cmdHandle;
this.adminCommand = adminCommand;
}
/*
* (non-Javadoc)
*
* @see org.bukkit.command.CommandExecutor#onCommand(org.bukkit.command.
* CommandSender , org.bukkit.command.Command, java.lang.String,
* java.lang.String[])
*/
@Override
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
ArrayList<String> argsNew = new ArrayList<String>();
argsNew.add(cmdHandle.getArgs()[0]);
for (String arg : args) {
argsNew.add(arg);
}
plugin.debug("Attempting cmd...");
plugin.debug("Inputed args: " + ArrayUtils.getInstance().makeStringList(argsNew));
ArrayList<CommandHandler> handles = new ArrayList<CommandHandler>();
if (adminCommand) {
handles.addAll(plugin.getAdminVoteCommand());
} else {
handles.addAll(plugin.getVoteCommand());
}
for (CommandHandler cmdHandle : handles) {
if (cmdHandle.getArgs().length > args.length) {
for (String arg : cmdHandle.getArgs()[0].split("&")) {
if (cmd.getName().equalsIgnoreCase("vote" + arg)
|| cmd.getName().equalsIgnoreCase("adminvote" + arg)) {
argsNew.set(0, arg);
boolean argsMatch = true;
for (int i = 0; i < argsNew.size(); i++) {
if (i < cmdHandle.getArgs().length) {
if (!cmdHandle.argsMatch(argsNew.get(i), i)) {
argsMatch = false;
}
}
}
if (argsMatch) {
if (cmdHandle.runCommand(sender, ArrayUtils.getInstance().convert(argsNew))) {
plugin.debug("cmd found, ran cmd");
return true;
}
}
}
}
}
}
/*
* for (String arg : cmdHandle.getArgs()[0].split("&")) { argsNew.set(0, arg);
* if (cmdHandle.runCommand(sender, Utils.getInstance().convertArray(argsNew)))
* { plugin.debug( "cmd found, ran cmd"); return true; } }
*/
// invalid command
if (adminCommand) {
sender.sendMessage(ChatColor.RED + "No valid arguments, see /adminvote help!");
} else {
sender.sendMessage(ChatColor.RED + "No valid arguments, see /vote help!");
}
return true;
}
}
@@ -1,69 +1,68 @@
package com.Ben12345rocks.VotingPlugin.Commands.Executers;
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import com.Ben12345rocks.AdvancedCore.Objects.CommandHandler;
import com.Ben12345rocks.VotingPlugin.Main;
// TODO: Auto-generated Javadoc
/**
* The Class CommandVote.
*/
public class CommandVote implements CommandExecutor {
/** The instance. */
private static CommandVote instance = new CommandVote();
/** The plugin. */
private static Main plugin;
/**
* Gets the single instance of CommandVote.
*
* @return single instance of CommandVote
*/
public static CommandVote getInstance() {
return instance;
}
/**
* Instantiates a new command vote.
*/
private CommandVote() {
}
/**
* Instantiates a new command vote.
*
* @param plugin
* the plugin
*/
public CommandVote(Main plugin) {
CommandVote.plugin = plugin;
}
/*
* (non-Javadoc)
*
* @see org.bukkit.command.CommandExecutor#onCommand(org.bukkit.command.
* CommandSender , org.bukkit.command.Command, java.lang.String,
* java.lang.String[])
*/
@Override
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
for (CommandHandler commandHandler : plugin.voteCommand) {
if (commandHandler.runCommand(sender, args)) {
return true;
}
}
// invalid command
sender.sendMessage(ChatColor.RED + "No valid arguments, see /vote help!");
return true;
}
}
package com.bencodez.votingplugin.commands.executers;
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import com.bencodez.advancedcore.api.command.CommandHandler;
import com.bencodez.votingplugin.VotingPluginMain;
// TODO: Auto-generated Javadoc
/**
* The Class CommandVote.
*/
public class CommandVote implements CommandExecutor {
/** The instance. */
private static CommandVote instance = new CommandVote();
/** The plugin. */
private static VotingPluginMain plugin;
/**
* Gets the single instance of CommandVote.
*
* @return single instance of CommandVote
*/
public static CommandVote getInstance() {
return instance;
}
/**
* Instantiates a new command vote.
*/
private CommandVote() {
}
/**
* Instantiates a new command vote.
*
* @param plugin the plugin
*/
public CommandVote(VotingPluginMain plugin) {
CommandVote.plugin = plugin;
}
/*
* (non-Javadoc)
*
* @see org.bukkit.command.CommandExecutor#onCommand(org.bukkit.command.
* CommandSender , org.bukkit.command.Command, java.lang.String,
* java.lang.String[])
*/
@Override
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
for (CommandHandler commandHandler : plugin.getVoteCommand()) {
if (commandHandler.runCommand(sender, args)) {
return true;
}
}
// invalid command
sender.sendMessage(ChatColor.RED + "No valid arguments, see /vote help!");
return true;
}
}
@@ -0,0 +1,349 @@
package com.bencodez.votingplugin.commands.gui;
import java.util.ArrayList;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.ClickType;
import org.bukkit.inventory.ItemStack;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.inventory.editgui.EditGUI;
import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton;
import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueBoolean;
import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueList;
import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueNumber;
import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueString;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.misc.ArrayUtils;
import com.bencodez.advancedcore.api.misc.PlayerUtils;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import com.bencodez.advancedcore.api.valuerequest.InputMethod;
import com.bencodez.advancedcore.api.valuerequest.ValueRequest;
import com.bencodez.advancedcore.api.valuerequest.ValueRequestBuilder;
import com.bencodez.advancedcore.api.valuerequest.listeners.StringListener;
import com.bencodez.advancedcore.command.gui.RewardEditGUI;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.commands.gui.admin.AdminVoteVoteParty;
import com.bencodez.votingplugin.commands.gui.admin.cumulative.AdminVoteCumulative;
import com.bencodez.votingplugin.commands.gui.admin.milestones.AdminVoteMilestones;
import com.bencodez.votingplugin.commands.gui.admin.voteshop.AdminVoteVoteShop;
import com.bencodez.votingplugin.events.PlayerVoteEvent;
import com.bencodez.votingplugin.objects.VoteSite;
public class AdminGUI {
private VotingPluginMain plugin;
public AdminGUI(VotingPluginMain plugin) {
this.plugin = plugin;
}
/**
* Open admin GUI.
*
* @return ArrayList of buttons
*/
public ArrayList<BInventoryButton> adminGUIButtons() {
ArrayList<BInventoryButton> buttons = new ArrayList<BInventoryButton>();
buttons.add(new BInventoryButton("&cVoteSites",
new String[] { "&cOnly enabled sites are listed in this section", "&cMiddle Click to create" },
new ItemStack(Material.STONE)) {
@Override
public void onClick(ClickEvent event) {
Player player = event.getPlayer();
if (event.getClick().equals(ClickType.MIDDLE)) {
new ValueRequest().requestString(player, new StringListener() {
@Override
public void onInput(Player player, String value) {
plugin.getConfigVoteSites().generateVoteSite(value);
player.sendMessage("Generated site");
plugin.reload();
}
});
} else {
openAdminGUIVoteSites(player);
}
}
});
buttons.add(new BInventoryButton(new ItemBuilder(Material.CHEST, 1).setName("&cEdit VoteShop")) {
@Override
public void onClick(ClickEvent clickEvent) {
new AdminVoteVoteShop(plugin, clickEvent.getPlayer()).open(GUIMethod.CHEST);
}
});
buttons.add(new BInventoryButton(new ItemBuilder(Material.DIAMOND_BLOCK, 1).setName("&cEdit Milestones")) {
@Override
public void onClick(ClickEvent clickEvent) {
new AdminVoteMilestones(plugin, clickEvent.getPlayer()).open(GUIMethod.CHEST);
}
});
buttons.add(new BInventoryButton(new ItemBuilder(Material.COBBLESTONE, 1).setName("&cEdit Cumulative")) {
@Override
public void onClick(ClickEvent clickEvent) {
new AdminVoteCumulative(plugin, clickEvent.getPlayer()).open(GUIMethod.CHEST);
}
});
buttons.add(new BInventoryButton(new ItemBuilder(Material.STONE, 1).setName("&cEdit VoteParty")) {
@Override
public void onClick(ClickEvent clickEvent) {
new AdminVoteVoteParty(plugin, clickEvent.getPlayer()).open(GUIMethod.CHEST);
}
});
buttons.add(new BInventoryButton(new ItemBuilder(Material.STONE, 1).setName("&cEdit FirstVote reward")) {
@Override
public void onClick(ClickEvent clickEvent) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(),
RewardHandler.getInstance().getDirectlyDefined("FirstVote"));
}
});
buttons.add(new BInventoryButton(new ItemBuilder(Material.STONE, 1).setName("&cEdit AllSites reward")) {
@Override
public void onClick(ClickEvent clickEvent) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(),
RewardHandler.getInstance().getDirectlyDefined("AllSites"));
}
});
buttons.add(new BInventoryButton(new ItemBuilder(Material.STONE, 1).setName("&cEdit AnySiteRewards")) {
@Override
public void onClick(ClickEvent clickEvent) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(),
RewardHandler.getInstance().getDirectlyDefined("AnySiteRewards"));
}
});
buttons.add(new BInventoryButton(new ItemBuilder(Material.STONE, 1).setName("&cEdit EverySiteReward")) {
@Override
public void onClick(ClickEvent clickEvent) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(),
RewardHandler.getInstance().getDirectlyDefined("EverySiteReward"));
}
});
buttons.add(new BInventoryButton("&cReload Plugin", new String[] {}, new ItemStack(Material.BUCKET, 1)) {
@Override
public void onClick(ClickEvent event) {
plugin.reload();
}
});
return buttons;
}
public void loadHook() {
for (BInventoryButton b : adminGUIButtons()) {
com.bencodez.advancedcore.command.gui.AdminGUI.getInstance().addButton(b);
}
}
/**
* Open admin GUI vote sites.
*
* @param player the player
*/
public void openAdminGUIVoteSites(Player player) {
BInventory inv = new BInventory("VoteSites");
int count = 0;
for (VoteSite voteSite : plugin.getVoteSites()) {
ArrayList<String> lore = new ArrayList<String>();
lore.add("Priority: " + voteSite.getPriority());
lore.add("Name: " + voteSite.getDisplayName());
lore.add("ServiceSite: " + voteSite.getServiceSite());
lore.add("VoteURL: " + voteSite.getVoteURL());
lore.add("VoteDelay: " + voteSite.getVoteDelay());
lore.add("VoteDelayMin: " + voteSite.getVoteDelayMin());
inv.addButton(count, new BInventoryButton(voteSite.getKey(), ArrayUtils.getInstance().convert(lore),
new ItemStack(Material.STONE)) {
@Override
public void onClick(ClickEvent event) {
Player player = event.getWhoClicked();
openAdminGUIVoteSiteSite(player, voteSite);
}
});
count++;
}
inv.openInventory(player);
}
/**
* Open admin GUI vote site site.
*
* @param player the player
* @param voteSite the vote site
*/
public void openAdminGUIVoteSiteSite(Player player, VoteSite voteSite) {
EditGUI inv = new EditGUI("VoteSite: " + voteSite.getDisplayName());
inv.setMeta(player, "VoteSite", voteSite);
inv.addButton(new BInventoryButton(voteSite.getItem().setName("&cForce vote")) {
@Override
public void onClick(ClickEvent event) {
ArrayList<String> playerNames = new ArrayList<String>();
for (Player p : Bukkit.getOnlinePlayers()) {
playerNames.add(p.getName());
}
new ValueRequestBuilder(new StringListener() {
@Override
public void onInput(Player player, String value) {
Object ob = PlayerUtils.getInstance().getPlayerMeta(player, "VoteSite");
if (ob != null) {
VoteSite site = (VoteSite) ob;
PlayerVoteEvent voteEvent = new PlayerVoteEvent(site, value, site.getServiceSite(), false);
plugin.getServer().getPluginManager().callEvent(voteEvent);
}
}
}, ArrayUtils.getInstance().convert(playerNames)).usingMethod(InputMethod.INVENTORY)
.allowCustomOption(true).request(event.getWhoClicked());
}
});
inv.addButton(new EditGUIButton(new EditGUIValueNumber("Priority", voteSite.getPriority()) {
@Override
public void setValue(Player player, Number num) {
VoteSite voteSite = (VoteSite) getInv().getMeta(player, "VoteSite");
plugin.getConfigVoteSites().setPriority(voteSite.getKey(), num.intValue());
plugin.reload();
}
}));
inv.addButton(new EditGUIButton(new EditGUIValueString("ServiceSite", voteSite.getServiceSite()) {
@Override
public void setValue(Player player, String value) {
VoteSite voteSite = (VoteSite) getInv().getMeta(player, "VoteSite");
String siteName = voteSite.getKey();
plugin.getConfigVoteSites().setServiceSite(siteName, value);
plugin.reload();
}
}));
inv.addButton(new EditGUIButton(new EditGUIValueString("Name", voteSite.getDisplayName()) {
@Override
public void setValue(Player player, String value) {
VoteSite voteSite = (VoteSite) getInv().getMeta(player, "VoteSite");
plugin.getConfigVoteSites().setDisplayName(voteSite.getKey(), value);
plugin.reload();
}
}));
inv.addButton(new EditGUIButton(new EditGUIValueString("VoteURL", voteSite.getVoteURL()) {
@Override
public void setValue(Player player, String value) {
VoteSite voteSite = (VoteSite) getInv().getMeta(player, "VoteSite");
String siteName = voteSite.getKey();
plugin.getConfigVoteSites().setVoteURL(siteName, value);
plugin.reload();
}
}));
inv.addButton(new EditGUIButton(new EditGUIValueNumber("VoteDelay", voteSite.getVoteDelay()) {
@Override
public void setValue(Player player, Number num) {
VoteSite voteSite = (VoteSite) getInv().getMeta(player, "VoteSite");
String siteName = voteSite.getKey();
plugin.getConfigVoteSites().setVoteDelay(siteName, num.intValue());
plugin.reload();
}
}));
inv.addButton(new EditGUIButton(new EditGUIValueNumber("VoteDelayMin", voteSite.getVoteDelay()) {
@Override
public void setValue(Player player, Number num) {
VoteSite voteSite = (VoteSite) getInv().getMeta(player, "VoteSite");
String siteName = voteSite.getKey();
plugin.getConfigVoteSites().setVoteDelay(siteName, num.intValue());
plugin.reload();
}
}));
inv.addButton(new EditGUIButton(new EditGUIValueBoolean("Enabled", voteSite.isEnabled()) {
@Override
public void setValue(Player player, boolean value) {
VoteSite voteSite = (VoteSite) getInv().getMeta(player, "VoteSite");
String siteName = voteSite.getKey();
plugin.getConfigVoteSites().setEnabled(siteName, value);
plugin.reload();
}
}));
inv.addButton(new EditGUIButton(new EditGUIValueBoolean("ForceOffline", voteSite.isGiveOffline()) {
@Override
public void setValue(Player player, boolean value) {
VoteSite voteSite = (VoteSite) getInv().getMeta(player, "VoteSite");
String siteName = voteSite.getKey();
plugin.getConfigVoteSites().setForceOffline(siteName, value);
plugin.reload();
}
}));
inv.addButton(new EditGUIButton(new EditGUIValueBoolean("VoteDelayDaily", voteSite.isVoteDelayDaily()) {
@Override
public void setValue(Player player, boolean value) {
VoteSite voteSite = (VoteSite) getInv().getMeta(player, "VoteSite");
String siteName = voteSite.getKey();
plugin.getConfigVoteSites().setVoteDelayDaily(siteName, value);
plugin.reload();
}
}));
if (voteSite.getSiteData().isList("Rewards")) {
inv.addButton(
new EditGUIButton(new EditGUIValueList("Rewards", voteSite.getSiteData().getStringList("Rewards")) {
@Override
public void setValue(Player p, ArrayList<String> rewards) {
VoteSite voteSite = (VoteSite) getInv().getMeta(player, "VoteSite");
plugin.getConfigVoteSites().set(voteSite.getKey(), "Rewards", rewards);
plugin.reload();
}
}));
} else {
inv.addButton(new BInventoryButton(new ItemBuilder(Material.DISPENSER, 1).setName("&cRewards")) {
@Override
public void onClick(ClickEvent clickEvent) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(), RewardHandler.getInstance()
.getDirectlyDefined("VoteSites." + voteSite.getKey() + ".Rewards"));
}
});
}
inv.openInventory(player);
}
}
@@ -0,0 +1,72 @@
package com.bencodez.votingplugin.commands.gui.admin;
import java.util.ArrayList;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.votingplugin.VotingPluginMain;
public abstract class AdminVoteConfirmation extends GUIHandler {
@SuppressWarnings("unused")
private VotingPluginMain plugin;
private String title;
public AdminVoteConfirmation(VotingPluginMain plugin, CommandSender player, String title) {
super(player);
this.plugin = plugin;
this.title = title;
}
@Override
public ArrayList<String> getChat(CommandSender sender) {
return null;
}
@Override
public void onBook(Player player) {
}
@Override
public void onChat(CommandSender sender) {
}
public abstract void onConfirm(Player p);
public abstract void onDeny(Player p);
@Override
public void onChest(Player player) {
BInventory inv = new BInventory(title);
inv.addButton(new BInventoryButton(new ItemBuilder(Material.EMERALD_BLOCK).setName("&aConfirm")) {
@Override
public void onClick(ClickEvent clickEvent) {
onConfirm(clickEvent.getPlayer());
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(Material.REDSTONE_BLOCK).setName("&aCancel")) {
@Override
public void onClick(ClickEvent clickEvent) {
onDeny(clickEvent.getPlayer());
}
});
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.CHEST);
}
}
@@ -0,0 +1,108 @@
package com.bencodez.votingplugin.commands.gui.admin;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.command.CommandHandler;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.messages.StringParser;
import com.bencodez.votingplugin.VotingPluginMain;
import net.md_5.bungee.api.chat.TextComponent;
public class AdminVoteHelp extends GUIHandler {
private int page;
private VotingPluginMain plugin;
public AdminVoteHelp(VotingPluginMain plugin, CommandSender player, int page) {
super(player);
this.plugin = plugin;
this.page = page;
}
/**
* Admin help.
*
* @param sender the sender
* @param page the page
* @return the array list
*/
public ArrayList<TextComponent> adminHelp(CommandSender sender, int page) {
int pagesize = plugin.getConfigFile().getFormatPageSize();
ArrayList<TextComponent> msg = new ArrayList<TextComponent>();
ArrayList<TextComponent> text = adminHelpText(sender);
int maxPage = text.size() / pagesize;
if ((text.size() % pagesize) != 0) {
maxPage++;
}
msg.add(StringParser.getInstance().stringToComp("&6&lVotingPlugin Admin Help " + (page) + "/" + maxPage));
msg.add(StringParser.getInstance().stringToComp("&6&l() = Needed"));
msg.add(StringParser.getInstance().stringToComp("&6&lAliases: adminvote, av"));
for (int i = pagesize * (page - 1); (i < text.size()) && (i < ((page) * pagesize)); i++) {
msg.add(text.get(i));
}
return msg;
}
/**
* Admin help text.
*
* @param sender the sender
* @return the array list
*/
public ArrayList<TextComponent> adminHelpText(CommandSender sender) {
ArrayList<TextComponent> msg = new ArrayList<TextComponent>();
HashMap<String, TextComponent> unsorted = new HashMap<String, TextComponent>();
boolean requirePerms = plugin.getConfigFile().getFormatCommandsVoteHelpRequirePermission();
for (CommandHandler cmdHandle : plugin.getAdminVoteCommand()) {
if (!requirePerms || cmdHandle.hasPerm(sender)) {
unsorted.put(cmdHandle.getHelpLineCommand("/adminvote"), cmdHandle.getHelpLine("/adminvote"));
}
}
ArrayList<String> unsortedList = new ArrayList<String>();
unsortedList.addAll(unsorted.keySet());
Collections.sort(unsortedList, String.CASE_INSENSITIVE_ORDER);
for (String cmd : unsortedList) {
msg.add(unsorted.get(cmd));
}
return msg;
}
@Override
public ArrayList<String> getChat(CommandSender sender) {
return null;
}
@Override
public void onBook(Player player) {
}
@Override
public void onChat(CommandSender sender) {
sendMessageJson(adminHelp(sender, page));
}
@Override
public void onChest(Player player) {
}
@Override
public void open() {
open(GUIMethod.CHAT);
}
}
@@ -0,0 +1,233 @@
package com.bencodez.votingplugin.commands.gui.admin;
import java.util.ArrayList;
import java.util.Set;
import java.util.regex.Pattern;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.permissions.Permission;
import com.bencodez.advancedcore.api.command.CommandHandler;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.misc.ArrayUtils;
import com.bencodez.votingplugin.VotingPluginMain;
public class AdminVotePerms extends GUIHandler {
private int page;
private String playerName;
private VotingPluginMain plugin;
public AdminVotePerms(VotingPluginMain plugin, CommandSender player, int page) {
super(player);
this.plugin = plugin;
this.page = page;
}
public AdminVotePerms(VotingPluginMain plugin, CommandSender player, int page, String playerName) {
super(player);
this.plugin = plugin;
this.page = page;
this.playerName = playerName;
}
@Override
public ArrayList<String> getChat(CommandSender sender) {
return null;
}
public String[] listPerms(CommandSender sender) {
ArrayList<String> msg = new ArrayList<String>();
for (CommandHandler handle : plugin.getVoteCommand()) {
if (sender instanceof Player) {
if (handle.hasPerm(sender)) {
msg.add("&6" + handle.getHelpLineCommand("/vote") + " : "
+ handle.getPerm().split(Pattern.quote("|"))[0] + " : &atrue");
} else {
msg.add("&6" + handle.getHelpLineCommand("/vote") + " : "
+ handle.getPerm().split(Pattern.quote("|"))[0] + " : &cfalse");
}
} else {
msg.add(handle.getHelpLineCommand("/vote") + " : " + handle.getPerm().split(Pattern.quote("|"))[0]);
}
}
for (CommandHandler handle : plugin.getAdminVoteCommand()) {
if (sender instanceof Player) {
if (handle.hasPerm(sender)) {
msg.add("&6" + handle.getHelpLineCommand("/av") + " : "
+ handle.getPerm().split(Pattern.quote("|"))[0] + " : &atrue");
} else {
msg.add("&6" + handle.getHelpLineCommand("/av") + " : "
+ handle.getPerm().split(Pattern.quote("|"))[0] + " : &cfalse");
}
} else {
msg.add(handle.getHelpLineCommand("/av") + " : " + handle.getPerm().split(Pattern.quote("|"))[0]);
}
}
for (Permission perm : plugin.getDescription().getPermissions()) {
if (sender instanceof Player) {
Set<String> child = perm.getChildren().keySet();
if (child.size() > 0) {
if (sender.hasPermission(perm)) {
msg.add("&6" + perm.getName() + " : &atrue");
} else {
msg.add("&6" + perm.getName() + " : &cfalse");
}
} else {
if (sender.hasPermission(perm)) {
msg.add("&6" + perm.getName() + " : &atrue");
} else {
msg.add("&6" + perm.getName() + " : &cfalse");
}
}
} else {
msg.add(perm.getName());
}
}
int pagesize = plugin.getConfigFile().getFormatPageSize();
int maxPage = msg.size() / pagesize;
if ((msg.size() % pagesize) != 0) {
maxPage++;
}
ArrayList<String> text = new ArrayList<String>();
text.add("&c&lCommand : Permissions " + page + "/" + maxPage);
for (int i = pagesize * page - pagesize; i < msg.size() && i < pagesize * page; i++) {
text.add(msg.get(i));
}
text = ArrayUtils.getInstance().colorize(text);
return ArrayUtils.getInstance().convert(text);
}
public ArrayList<String> listPerms(CommandSender sender, String player, int page) {
Player p = Bukkit.getPlayer(player);
ArrayList<String> text = new ArrayList<String>();
if (p != null) {
ArrayList<String> msg = new ArrayList<String>();
for (CommandHandler handle : plugin.getVoteCommand()) {
if (handle.hasPerm(p)) {
msg.add("&6" + handle.getHelpLineCommand("/vote") + " : "
+ handle.getPerm().split(Pattern.quote("|"))[0] + " : &atrue");
} else {
msg.add("&6" + handle.getHelpLineCommand("/vote") + " : "
+ handle.getPerm().split(Pattern.quote("|"))[0] + " : &cfalse");
}
}
for (CommandHandler handle : plugin.getAdminVoteCommand()) {
if (handle.hasPerm(p)) {
msg.add("&6" + handle.getHelpLineCommand("/av") + " : "
+ handle.getPerm().split(Pattern.quote("|"))[0] + " : &atrue");
} else {
msg.add("&6" + handle.getHelpLineCommand("/av") + " : "
+ handle.getPerm().split(Pattern.quote("|"))[0] + " : &cfalse");
}
}
for (Permission perm : plugin.getDescription().getPermissions()) {
Set<String> child = perm.getChildren().keySet();
if (child.size() > 0) {
if (p.hasPermission(perm)) {
msg.add("&6" + perm.getName() + " : &atrue");
} else {
msg.add("&6" + perm.getName() + " : &cfalse");
}
} else {
if (p.hasPermission(perm)) {
msg.add("&6" + perm.getName() + " : &atrue");
} else {
msg.add("&6" + perm.getName() + " : &cfalse");
}
}
}
msg = ArrayUtils.getInstance().colorize(msg);
int pagesize = plugin.getConfigFile().getFormatPageSize();
int maxPage = msg.size() / pagesize;
if ((msg.size() % pagesize) != 0) {
maxPage++;
}
text.add("&c&lCommand : Permissions for " + player + " " + page + "/" + maxPage);
for (int i = pagesize * page - pagesize; i < msg.size() && i < pagesize * page; i++) {
text.add(msg.get(i));
}
} else {
text.add("&cPlayer not online: " + player);
}
return ArrayUtils.getInstance().colorize(text);
}
public String[] listPermsDev(CommandSender sender) {
ArrayList<String> msg = new ArrayList<String>();
msg.add("Command");
msg.add(" Permissions (seperated by |");
msg.add(" Help messasge");
msg.add(" ");
for (CommandHandler handle : plugin.getVoteCommand()) {
msg.add(handle.getHelpLineCommand("/vote"));
msg.add(" " + handle.getPerm());
msg.add(" " + handle.getHelpMessage());
}
for (CommandHandler handle : plugin.getAdminVoteCommand()) {
msg.add(handle.getHelpLineCommand("/av"));
msg.add(" " + handle.getPerm());
msg.add(" " + handle.getHelpMessage());
}
for (Permission perm : plugin.getDescription().getPermissions()) {
msg.add(perm.getName() + " : " + perm.getDescription());
}
msg = ArrayUtils.getInstance().colorize(msg);
return ArrayUtils.getInstance().convert(msg);
}
@Override
public void onBook(Player player) {
}
@Override
public void onChat(CommandSender sender) {
if (playerName != null) {
sendMessage(listPerms(sender, playerName, page));
} else {
sendMessage(listPerms(sender));
}
}
@Override
public void onChest(Player player) {
}
@Override
public void open() {
open(GUIMethod.CHAT);
}
}
@@ -0,0 +1,121 @@
package com.bencodez.votingplugin.commands.gui.admin;
import java.util.ArrayList;
import java.util.Arrays;
import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.bookgui.BookWrapper;
import com.bencodez.advancedcore.api.bookgui.Layout;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.placeholder.PlaceHolder;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.user.VotingPluginUser;
import xyz.upperlevel.spigot.book.BookUtil;
public class AdminVotePlaceholders extends GUIHandler {
@SuppressWarnings("unused")
private VotingPluginMain plugin;
public AdminVotePlaceholders(VotingPluginMain plugin, CommandSender player) {
super(player);
this.plugin = plugin;
}
@Override
public ArrayList<String> getChat(CommandSender sender) {
return null;
}
@Override
public void onBook(Player player) {
BookWrapper book = new BookWrapper("Placeholders");
for (PlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getPlaceholders()) {
String msg = "";
String identifier = placeholder.getIdentifier();
if (identifier.endsWith("_")) {
identifier += "#";
}
if (placeholder.hasDescription()) {
msg = "VotingPlugin_" + identifier + " - " + placeholder.getDescription();
} else {
msg = "VotingPlugin_" + identifier + "";
}
Layout layout = new Layout(new ArrayList<String>(Arrays.asList("[Json]")));
layout.replaceTextComponent("[Json]", BookUtil.TextBuilder.of(identifier).color(ChatColor.AQUA)
.onHover(BookUtil.HoverAction.showText(msg)).build());
book.addLayout(layout);
}
for (PlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getNonPlayerPlaceholders()) {
String msg = "";
String identifier = placeholder.getIdentifier();
if (identifier.endsWith("_")) {
identifier += "#";
}
if (placeholder.hasDescription()) {
msg = "VotingPlugin_" + identifier + " - " + placeholder.getDescription();
} else {
msg = "VotingPlugin_" + identifier + "";
}
Layout layout = new Layout(new ArrayList<String>(Arrays.asList("[Json]")));
layout.replaceTextComponent("[Json]", BookUtil.TextBuilder.of(identifier).color(ChatColor.AQUA)
.onHover(BookUtil.HoverAction.showText(msg)).build());
book.addLayout(layout);
}
book.open(player);
}
@Override
public void onChat(CommandSender sender) {
ArrayList<String> msg = new ArrayList<String>();
msg.add("&cPlaceholders:");
for (PlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getPlaceholders()) {
String identifier = placeholder.getIdentifier();
if (identifier.endsWith("_")) {
identifier += "#";
}
if (placeholder.hasDescription()) {
msg.add("VotingPlugin_" + identifier + " - " + placeholder.getDescription());
} else {
msg.add("VotingPlugin_" + identifier + "");
}
}
for (PlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getNonPlayerPlaceholders()) {
String identifier = placeholder.getIdentifier();
if (identifier.endsWith("_")) {
identifier += "#";
}
if (placeholder.hasDescription()) {
msg.add("VotingPlugin_" + identifier + " - " + placeholder.getDescription());
} else {
msg.add("VotingPlugin_" + identifier + "");
}
}
sendMessage(msg);
}
@Override
public void onChest(Player player) {
}
@Override
public void open() {
open(GUIMethod.CHAT);
}
}
@@ -0,0 +1,111 @@
package com.bencodez.votingplugin.commands.gui.admin;
import java.util.ArrayList;
import java.util.Arrays;
import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.bookgui.BookWrapper;
import com.bencodez.advancedcore.api.bookgui.Layout;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.placeholder.PlaceHolder;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.user.UserManager;
import com.bencodez.votingplugin.user.VotingPluginUser;
import xyz.upperlevel.spigot.book.BookUtil;
public class AdminVotePlaceholdersPlayer extends GUIHandler {
@SuppressWarnings("unused")
private VotingPluginMain plugin;
private VotingPluginUser user;
public AdminVotePlaceholdersPlayer(VotingPluginMain plugin, CommandSender player, VotingPluginUser user) {
super(player);
this.plugin = plugin;
this.user = user;
}
@Override
public ArrayList<String> getChat(CommandSender sender) {
return null;
}
@Override
public void onBook(Player player) {
BookWrapper book = new BookWrapper("Placeholders");
for (PlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getPlaceholders()) {
String identifier = placeholder.getIdentifier();
if (identifier.endsWith("_")) {
identifier += "1";
}
String value = placeholder.placeholderRequest(user.getOfflinePlayer(), user, identifier);
String msg = identifier + " = " + value;
Layout layout = new Layout(new ArrayList<String>(Arrays.asList("[Json]")));
layout.replaceTextComponent("[Json]", BookUtil.TextBuilder.of(msg).color(ChatColor.AQUA)
.onHover(BookUtil.HoverAction.showText(value)).build());
book.addLayout(layout);
}
for (PlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getNonPlayerPlaceholders()) {
String identifier = placeholder.getIdentifier();
if (identifier.endsWith("_")) {
identifier += "1";
}
String value = placeholder.placeholderRequest(user.getOfflinePlayer(), user, identifier);
String msg = identifier + " = " + value;
Layout layout = new Layout(new ArrayList<String>(Arrays.asList("[Json]")));
layout.replaceTextComponent("[Json]", BookUtil.TextBuilder.of(msg).color(ChatColor.AQUA)
.onHover(BookUtil.HoverAction.showText(value)).build());
book.addLayout(layout);
}
book.open(player);
}
@Override
public void onChat(CommandSender sender) {
ArrayList<String> msg = new ArrayList<String>();
msg.add("&cPlaceholders:");
VotingPluginUser placeholderUser = user;
if (plugin.getConfigFile().isUsePrimaryAccountForPlaceholders() && user.hasPrimaryAccount()) {
placeholderUser = UserManager.getInstance().getVotingPluginUser(user.getPrimaryAccount());
}
for (PlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getPlaceholders()) {
String identifier = placeholder.getIdentifier();
if (identifier.endsWith("_")) {
identifier += "1";
}
msg.add("VotingPlugin_" + identifier + " = "
+ placeholder.placeholderRequest(user.getOfflinePlayer(), placeholderUser, identifier));
}
for (PlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getNonPlayerPlaceholders()) {
String identifier = placeholder.getIdentifier();
if (identifier.endsWith("_")) {
identifier += "1";
}
msg.add("VotingPlugin_" + identifier + " = "
+ placeholder.placeholderRequest(user.getOfflinePlayer(), placeholderUser, identifier));
}
sendMessage(msg);
}
@Override
public void onChest(Player player) {
}
@Override
public void open() {
open(GUIMethod.CHAT);
}
}
@@ -0,0 +1,226 @@
package com.bencodez.votingplugin.commands.gui.admin;
import java.util.ArrayList;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.inventory.editgui.EditGUI;
import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton;
import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueBoolean;
import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueList;
import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueNumber;
import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueString;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import com.bencodez.advancedcore.api.valuerequest.ValueRequestBuilder;
import com.bencodez.advancedcore.api.valuerequest.listeners.NumberListener;
import com.bencodez.advancedcore.command.gui.RewardEditGUI;
import com.bencodez.votingplugin.VotingPluginMain;
public class AdminVoteVoteParty extends GUIHandler {
private VotingPluginMain plugin;
public AdminVoteVoteParty(VotingPluginMain plugin, CommandSender player) {
super(player);
this.plugin = plugin;
}
@Override
public ArrayList<String> getChat(CommandSender sender) {
return null;
}
@Override
public void onBook(Player player) {
}
@Override
public void onChat(CommandSender sender) {
}
private void setPathData(String path, Object value) {
plugin.getSpecialRewardsConfig().getData().set("VoteParty." + path, value);
plugin.getSpecialRewardsConfig().saveData();
plugin.reload();
}
@Override
public void onChest(Player player) {
EditGUI inv = new EditGUI("Edit VoteParty");
inv.requirePermission("VotingPlugin.Commands.AdminVote.Edit.VoteParty");
// to add
inv.addButton(new EditGUIButton(new ItemBuilder(Material.PAPER, 1),
new EditGUIValueBoolean("Enabled", plugin.getSpecialRewardsConfig().getVotePartyEnabled()) {
@Override
public void setValue(Player player, boolean name) {
setPathData(getKey(), name);
}
}));
inv.addButton(new EditGUIButton(new ItemBuilder(Material.EMERALD, 1),
new EditGUIValueNumber("VotesRequired", plugin.getSpecialRewardsConfig().getVotePartyVotesRequired()) {
@Override
public void setValue(Player player, Number num) {
setPathData(getKey(), num.intValue());
}
}));
inv.addButton(new EditGUIButton(new ItemBuilder(Material.LADDER, 1), new EditGUIValueNumber(
"IncreaseVotesRquired", plugin.getSpecialRewardsConfig().getVotePartyIncreaseVotesRquired()) {
@Override
public void setValue(Player player, Number num) {
setPathData(getKey(), num.intValue());
}
}));
inv.addButton(new BInventoryButton(new ItemBuilder(Material.LADDER).setName("&cCurrent increase amount")
.addLoreLine("&cCurrent value: " + plugin.getServerData().getVotePartyExtraRequired())) {
@Override
public void onClick(ClickEvent clickEvent) {
new ValueRequestBuilder(new NumberListener() {
@Override
public void onInput(Player player, Number value) {
plugin.getServerData().setVotePartyExtraRequired(value.intValue());
}
}, new Number[] { 0, 10, 50, 100 })
.currentValue("" + plugin.getServerData().getVotePartyExtraRequired()).allowCustomOption(true)
.request(clickEvent.getPlayer());
;
}
});
inv.addButton(new EditGUIButton(new ItemBuilder(Material.EMERALD, 1), new EditGUIValueNumber(
"UserVotesRequired", plugin.getSpecialRewardsConfig().getVotePartyUserVotesRequired()) {
@Override
public void setValue(Player player, Number num) {
setPathData(getKey(), num.intValue());
}
}));
inv.addButton(new EditGUIButton(new ItemBuilder(Material.PAPER, 1), new EditGUIValueBoolean("GiveAllPlayers",
plugin.getSpecialRewardsConfig().getVotePartyGiveAllPlayers()) {
@Override
public void setValue(Player player, boolean name) {
setPathData(getKey(), name);
}
}));
inv.addButton(new EditGUIButton(new ItemBuilder(Material.PAPER, 1),
new EditGUIValueBoolean("ResetEachDay", plugin.getSpecialRewardsConfig().getVotePartyResetEachDay()) {
@Override
public void setValue(Player player, boolean name) {
setPathData(getKey(), name);
}
}));
inv.addButton(new EditGUIButton(new ItemBuilder(Material.PAPER, 1),
new EditGUIValueBoolean("ResetWeekly", plugin.getSpecialRewardsConfig().getVotePartyResetWeekly()) {
@Override
public void setValue(Player player, boolean name) {
setPathData(getKey(), name);
}
}));
inv.addButton(new EditGUIButton(new ItemBuilder(Material.PAPER, 1),
new EditGUIValueBoolean("ResetMonthly", plugin.getSpecialRewardsConfig().getVotePartyResetMontly()) {
@Override
public void setValue(Player player, boolean name) {
setPathData(getKey(), name);
}
}));
inv.addButton(new EditGUIButton(new ItemBuilder(Material.PAPER, 1), new EditGUIValueBoolean("OnlyOncePerDay",
plugin.getSpecialRewardsConfig().getVotePartyOnlyOncePerDay()) {
@Override
public void setValue(Player player, boolean name) {
setPathData(getKey(), name);
}
}));
inv.addButton(new EditGUIButton(new ItemBuilder(Material.PAPER, 1), new EditGUIValueBoolean(
"ResetExtraVotesMonthly", plugin.getSpecialRewardsConfig().isVotePartyResetExtraVotesMonthly()) {
@Override
public void setValue(Player player, boolean name) {
setPathData(getKey(), name);
}
}));
inv.addButton(new EditGUIButton(new ItemBuilder(Material.PAPER, 1), new EditGUIValueBoolean("CountFakeVotes",
plugin.getSpecialRewardsConfig().getVotePartyCountFakeVotes()) {
@Override
public void setValue(Player player, boolean name) {
setPathData(getKey(), name);
}
}));
inv.addButton(new EditGUIButton(new ItemBuilder(Material.PAPER, 1), new EditGUIValueBoolean("CountOfflineVotes",
plugin.getSpecialRewardsConfig().getVotePartyCountOfflineVotes()) {
@Override
public void setValue(Player player, boolean name) {
setPathData(getKey(), name);
}
}));
inv.addButton(new EditGUIButton(new ItemBuilder(Material.PAPER, 1),
new EditGUIValueString("Broadcast", plugin.getSpecialRewardsConfig().getVotePartyBroadcast()) {
@Override
public void setValue(Player player, String name) {
setPathData(getKey(), name);
}
}));
inv.addButton(new EditGUIButton(new ItemBuilder(Material.PAPER, 1),
new EditGUIValueList("Commands", plugin.getSpecialRewardsConfig().getVotePartyCommands()) {
@Override
public void setValue(Player player, ArrayList<String> value) {
setPathData(getKey(), value);
}
}));
inv.addButton(new BInventoryButton(new ItemBuilder(Material.DISPENSER, 1).setName("&cRewards")
.addLoreLine("&aUse this for per player rewards, also set online only rewards here as well")
.addLoreLine("&cTo set rewards to be given to players online only, set RewardType to ONLINE")) {
@Override
public void onClick(ClickEvent clickEvent) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(),
RewardHandler.getInstance().getDirectlyDefined("VoteParty.Rewards"));
}
});
// implement item reward?
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.CHEST);
}
}
@@ -0,0 +1,106 @@
package com.bencodez.votingplugin.commands.gui.admin.cumulative;
import java.util.ArrayList;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.messages.StringParser;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import com.bencodez.advancedcore.api.valuerequest.InputMethod;
import com.bencodez.advancedcore.api.valuerequest.ValueRequest;
import com.bencodez.advancedcore.api.valuerequest.ValueRequestBuilder;
import com.bencodez.advancedcore.api.valuerequest.listeners.NumberListener;
import com.bencodez.advancedcore.command.gui.RewardEditGUI;
import com.bencodez.votingplugin.VotingPluginMain;
public class AdminVoteCumulative extends GUIHandler {
private VotingPluginMain plugin;
public AdminVoteCumulative(VotingPluginMain plugin, CommandSender player) {
super(player);
this.plugin = plugin;
}
@Override
public ArrayList<String> getChat(CommandSender sender) {
return null;
}
@Override
public void onBook(Player player) {
}
@Override
public void onChat(CommandSender sender) {
}
@Override
public void onChest(Player player) {
BInventory inv = new BInventory("Edit Cumulative");
inv.requirePermission("VotingPlugin.Commands.AdminVote.Edit.Cumulative");
inv.addButton(new BInventoryButton(new ItemBuilder(Material.PAPER).setName("&cEdit existing cumulative rewards")) {
@Override
public void onClick(ClickEvent clickEvent) {
ArrayList<Integer> nums = new ArrayList<Integer>();
for (String num : plugin.getSpecialRewardsConfig().getCumulativeVotes()) {
if (StringParser.getInstance().isInt(num)) {
nums.add(Integer.parseInt(num));
}
}
Number[] options = new Number[nums.size()];
for (int i = 0; i < nums.size(); i++) {
options[i] = nums.get(i);
}
new ValueRequestBuilder(new NumberListener() {
@Override
public void onInput(Player player, Number value) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(),
RewardHandler.getInstance().getDirectlyDefined("Cumulative." + value.intValue() + ".Rewards"));
}
}, options).allowCustomOption(false).usingMethod(InputMethod.INVENTORY).request(clickEvent.getPlayer());;
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(Material.EMERALD_BLOCK).setName("&aAdd cumulative reward")) {
@Override
public void onClick(ClickEvent clickEvent) {
new ValueRequest().requestNumber(player, new NumberListener() {
@Override
public void onInput(Player player, Number value) {
plugin.getSpecialRewardsConfig().setCumulative(value.intValue());
plugin.reload();
}
});
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(Material.REDSTONE_BLOCK).setName("&cRemove cumulative")) {
@Override
public void onClick(ClickEvent clickEvent) {
new AdminVoteCumulativeRemove(plugin, clickEvent.getPlayer()).open();
}
});
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.CHEST);
}
}
@@ -0,0 +1,77 @@
package com.bencodez.votingplugin.commands.gui.admin.cumulative;
import java.util.ArrayList;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.commands.gui.admin.AdminVoteConfirmation;
public class AdminVoteCumulativeRemove extends GUIHandler {
private VotingPluginMain plugin;
public AdminVoteCumulativeRemove(VotingPluginMain plugin, CommandSender player) {
super(player);
this.plugin = plugin;
}
@Override
public ArrayList<String> getChat(CommandSender sender) {
return null;
}
@Override
public void onBook(Player player) {
}
@Override
public void onChat(CommandSender sender) {
}
@Override
public void onChest(Player player) {
BInventory inv = new BInventory("Remove cumulative");
inv.requirePermission("VotingPlugin.Commands.AdminVote.Edit.Cumulative");
for (final String votes : plugin.getSpecialRewardsConfig().getCumulativeVotes()) {
inv.addButton(new BInventoryButton(
new ItemBuilder(Material.PAPER, 1).setName(votes).addLoreLine("&c&lClick to remove")) {
@Override
public void onClick(ClickEvent clickEvent) {
new AdminVoteConfirmation(plugin, clickEvent.getPlayer(), "Remove cumulative " + votes + "?") {
@Override
public void onDeny(Player p) {
new AdminVoteCumulative(plugin, p);
}
@Override
public void onConfirm(Player p) {
plugin.getSpecialRewardsConfig().removeCumulative(votes);
p.sendMessage("Removed cumulative " + votes);
plugin.reload();
}
}.open();;
}
});
}
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.CHEST);
}
}
@@ -0,0 +1,77 @@
package com.bencodez.votingplugin.commands.gui.admin.milestones;
import java.util.ArrayList;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.commands.gui.admin.AdminVoteConfirmation;
public class AdminVoteMilestoneRemove extends GUIHandler {
private VotingPluginMain plugin;
public AdminVoteMilestoneRemove(VotingPluginMain plugin, CommandSender player) {
super(player);
this.plugin = plugin;
}
@Override
public ArrayList<String> getChat(CommandSender sender) {
return null;
}
@Override
public void onBook(Player player) {
}
@Override
public void onChat(CommandSender sender) {
}
@Override
public void onChest(Player player) {
BInventory inv = new BInventory("Remove milestones");
inv.requirePermission("VotingPlugin.Commands.AdminVote.Edit.MileStones");
for (final String votes : plugin.getSpecialRewardsConfig().getMilestoneVotes()) {
inv.addButton(new BInventoryButton(
new ItemBuilder(Material.PAPER, 1).setName(votes).addLoreLine("&c&lClick to remove")) {
@Override
public void onClick(ClickEvent clickEvent) {
new AdminVoteConfirmation(plugin, clickEvent.getPlayer(), "Remove milestone " + votes + "?") {
@Override
public void onDeny(Player p) {
new AdminVoteMilestones(plugin, p);
}
@Override
public void onConfirm(Player p) {
plugin.getSpecialRewardsConfig().removeMilestone(votes);
p.sendMessage("Removed milestone " + votes);
plugin.reload();
}
}.open();;
}
});
}
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.CHEST);
}
}
@@ -0,0 +1,108 @@
package com.bencodez.votingplugin.commands.gui.admin.milestones;
import java.util.ArrayList;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.messages.StringParser;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import com.bencodez.advancedcore.api.valuerequest.InputMethod;
import com.bencodez.advancedcore.api.valuerequest.ValueRequest;
import com.bencodez.advancedcore.api.valuerequest.ValueRequestBuilder;
import com.bencodez.advancedcore.api.valuerequest.listeners.NumberListener;
import com.bencodez.advancedcore.command.gui.RewardEditGUI;
import com.bencodez.votingplugin.VotingPluginMain;
public class AdminVoteMilestones extends GUIHandler {
private VotingPluginMain plugin;
public AdminVoteMilestones(VotingPluginMain plugin, CommandSender player) {
super(player);
this.plugin = plugin;
}
@Override
public ArrayList<String> getChat(CommandSender sender) {
return null;
}
@Override
public void onBook(Player player) {
}
@Override
public void onChat(CommandSender sender) {
}
@Override
public void onChest(Player player) {
BInventory inv = new BInventory("Edit MileStones");
inv.requirePermission("VotingPlugin.Commands.AdminVote.Edit.MileStones");
inv.addButton(
new BInventoryButton(new ItemBuilder(Material.PAPER).setName("&cEdit existing milestone rewards")) {
@Override
public void onClick(ClickEvent clickEvent) {
ArrayList<Integer> nums = new ArrayList<Integer>();
for (String num : plugin.getSpecialRewardsConfig().getMilestoneVotes()) {
if (StringParser.getInstance().isInt(num)) {
nums.add(Integer.parseInt(num));
}
}
Number[] options = new Number[nums.size()];
for (int i = 0; i < nums.size(); i++) {
options[i] = nums.get(i);
}
new ValueRequestBuilder(new NumberListener() {
@Override
public void onInput(Player player, Number value) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(),
RewardHandler.getInstance()
.getDirectlyDefined("MileStones." + value.intValue() + ".Rewards"));
}
}, options).allowCustomOption(false).usingMethod(InputMethod.INVENTORY).request(clickEvent.getPlayer());;
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(Material.EMERALD_BLOCK).setName("&aAdd milestone")) {
@Override
public void onClick(ClickEvent clickEvent) {
new ValueRequest().requestNumber(player, new NumberListener() {
@Override
public void onInput(Player player, Number value) {
plugin.getSpecialRewardsConfig().setMilestone(value.intValue());
plugin.reload();
}
});
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(Material.REDSTONE_BLOCK).setName("&cRemove milestone")) {
@Override
public void onClick(ClickEvent clickEvent) {
new AdminVoteMilestoneRemove(plugin, clickEvent.getPlayer()).open();
}
});
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.CHEST);
}
}
@@ -0,0 +1,84 @@
package com.bencodez.votingplugin.commands.gui.admin.voteshop;
import java.util.ArrayList;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.valuerequest.ValueRequest;
import com.bencodez.advancedcore.api.valuerequest.listeners.StringListener;
import com.bencodez.votingplugin.VotingPluginMain;
public class AdminVoteVoteShop extends GUIHandler {
private VotingPluginMain plugin;
public AdminVoteVoteShop(VotingPluginMain plugin, CommandSender player) {
super(player);
this.plugin = plugin;
}
@Override
public ArrayList<String> getChat(CommandSender sender) {
return null;
}
@Override
public void onBook(Player player) {
}
@Override
public void onChat(CommandSender sender) {
}
@Override
public void onChest(Player player) {
BInventory inv = new BInventory("Edit VoteShop");
inv.requirePermission("VotingPlugin.Commands.AdminVote.Edit.VoteShop");
inv.addButton(new BInventoryButton(new ItemBuilder(Material.DIAMOND).setName("&cEdit existing item")) {
@Override
public void onClick(ClickEvent clickEvent) {
new AdminVoteVoteShopItems(plugin, clickEvent.getPlayer()).open(GUIMethod.CHEST);
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(Material.EMERALD_BLOCK).setName("&aAdd voteshop item")) {
@Override
public void onClick(ClickEvent clickEvent) {
new ValueRequest().requestString(player, new StringListener() {
@Override
public void onInput(Player player, String value) {
plugin.getGui().createShop(value);
plugin.reload();
}
});
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(Material.REDSTONE_BLOCK).setName("&cRemove item")) {
@Override
public void onClick(ClickEvent clickEvent) {
new AdminVoteVoteShopItemRemove(plugin, clickEvent.getPlayer()).open();
}
});
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.CHEST);
}
}
@@ -0,0 +1,138 @@
package com.bencodez.votingplugin.commands.gui.admin.voteshop;
import java.util.ArrayList;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.editgui.EditGUI;
import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton;
import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueList;
import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueNumber;
import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueString;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import com.bencodez.advancedcore.command.gui.RewardEditGUI;
import com.bencodez.votingplugin.VotingPluginMain;
public class AdminVoteVoteShopItem extends GUIHandler {
private VotingPluginMain plugin;
private String identifier;
public AdminVoteVoteShopItem(VotingPluginMain plugin, CommandSender player, String identifier) {
super(player);
this.plugin = plugin;
this.identifier = identifier;
}
@Override
public ArrayList<String> getChat(CommandSender sender) {
return null;
}
@Override
public void onBook(Player player) {
}
@Override
public void onChat(CommandSender sender) {
}
private void setPathData(String path, Object value) {
plugin.getGui().getData().set("CHEST.Shop." + identifier + "." + path, value);
plugin.getGui().saveData();
plugin.reload();
}
@Override
public void onChest(Player player) {
EditGUI inv = new EditGUI("Edit VoteShop Item: " + identifier);
inv.requirePermission("VotingPlugin.Commands.AdminVote.Edit.VoteShop");
// to add
inv.addButton(new EditGUIButton(new ItemBuilder(Material.PAPER, 1), new EditGUIValueString("Identifier_Name",
plugin.getGui().getChestShopIdentifierIdentifierName(identifier)) {
@Override
public void setValue(Player player, String name) {
setPathData(getKey(), name);
}
}));
inv.addButton(new EditGUIButton(new ItemBuilder(Material.OAK_DOOR, 1),
new EditGUIValueString("Permission", plugin.getGui().getChestVoteShopPermission(identifier)) {
@Override
public void setValue(Player player, String name) {
setPathData(getKey(), name);
}
}));
inv.addButton(new EditGUIButton(new ItemBuilder(Material.EMERALD, 1),
new EditGUIValueNumber("Cost", plugin.getGui().getChestShopIdentifierCost(identifier)) {
@Override
public void setValue(Player player, Number num) {
setPathData(getKey(), num.intValue());
}
}));
inv.addButton(new EditGUIButton(new ItemBuilder(Material.BARRIER, 1),
new EditGUIValueNumber("Limit", plugin.getGui().getChestShopIdentifierLimit(identifier)) {
@Override
public void setValue(Player player, Number num) {
setPathData(getKey(), num.intValue());
}
}));
// display item
ConfigurationSection displayItemData = plugin.getGui().getChestShopIdentifierSection(identifier);
inv.addButton(new EditGUIButton(new ItemBuilder(Material.valueOf(displayItemData.getString("Material")), 1),
new EditGUIValueString("Material", displayItemData.getString("Material")) {
@Override
public void setValue(Player player, String name) {
setPathData(getKey(), name);
}
}));
inv.addButton(new EditGUIButton(new ItemBuilder(Material.PAPER, 1),
new EditGUIValueString("Name", displayItemData.getString("Name")) {
@Override
public void setValue(Player player, String name) {
setPathData(getKey(), name);
}
}));
inv.addButton(new EditGUIButton(new ItemBuilder(Material.BOOK, 1),
new EditGUIValueList("Lore", displayItemData.getStringList("Lore")) {
@Override
public void setValue(Player player, ArrayList<String> value) {
setPathData(getKey(), value);
}
}));
inv.addButton(new BInventoryButton(new ItemBuilder(Material.DISPENSER, 1).setName("&cRewards")) {
@Override
public void onClick(ClickEvent clickEvent) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(),
RewardHandler.getInstance().getDirectlyDefined("CHEST.Shop." + identifier + ".Rewards"));
}
});
// implement item reward?
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.CHEST);
}
}
@@ -0,0 +1,79 @@
package com.bencodez.votingplugin.commands.gui.admin.voteshop;
import java.util.ArrayList;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.commands.gui.admin.AdminVoteConfirmation;
public class AdminVoteVoteShopItemRemove extends GUIHandler {
private VotingPluginMain plugin;
public AdminVoteVoteShopItemRemove(VotingPluginMain plugin, CommandSender player) {
super(player);
this.plugin = plugin;
}
@Override
public ArrayList<String> getChat(CommandSender sender) {
return null;
}
@Override
public void onBook(Player player) {
}
@Override
public void onChat(CommandSender sender) {
}
@Override
public void onChest(Player player) {
BInventory inv = new BInventory("Edit VoteShop Remove Item");
inv.requirePermission("VotingPlugin.Commands.AdminVote.Edit.VoteShop");
for (final String identifier : plugin.getGui().getChestShopIdentifiers()) {
inv.addButton(
new BInventoryButton(new ItemBuilder(plugin.getGui().getChestShopIdentifierSection(identifier))
.addLoreLine("&c&lClick to remove")) {
@Override
public void onClick(ClickEvent clickEvent) {
new AdminVoteConfirmation(plugin, clickEvent.getPlayer(),
"Remove shop item " + identifier + "?") {
@Override
public void onDeny(Player p) {
new AdminVoteVoteShop(plugin, p).open();
}
@Override
public void onConfirm(Player p) {
plugin.getGui().removeShop(identifier);
p.sendMessage("Removed " + identifier);
plugin.reload();
}
}.open();;
}
}.addData("ident", identifier));
}
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.CHEST);
}
}
@@ -0,0 +1,65 @@
package com.bencodez.votingplugin.commands.gui.admin.voteshop;
import java.util.ArrayList;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.votingplugin.VotingPluginMain;
public class AdminVoteVoteShopItems extends GUIHandler {
private VotingPluginMain plugin;
public AdminVoteVoteShopItems(VotingPluginMain plugin, CommandSender player) {
super(player);
this.plugin = plugin;
}
@Override
public ArrayList<String> getChat(CommandSender sender) {
return null;
}
@Override
public void onBook(Player player) {
}
@Override
public void onChat(CommandSender sender) {
}
@Override
public void onChest(Player player) {
BInventory inv = new BInventory("Edit VoteShop Items");
inv.requirePermission("VotingPlugin.Commands.AdminVote.Edit.VoteShop");
for (String identifier : plugin.getGui().getChestShopIdentifiers()) {
inv.addButton(
new BInventoryButton(new ItemBuilder(plugin.getGui().getChestShopIdentifierSection(identifier))) {
@Override
public void onClick(ClickEvent clickEvent) {
new AdminVoteVoteShopItem(plugin, clickEvent.getPlayer(), (String) getData("ident"))
.open(GUIMethod.CHEST);
;
}
}.addData("ident", identifier));
}
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.CHEST);
}
}
@@ -0,0 +1,99 @@
package com.bencodez.votingplugin.commands.gui.player;
import java.util.ArrayList;
import java.util.HashMap;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.misc.ArrayUtils;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.user.VotingPluginUser;
public class VoteBest extends GUIHandler {
@SuppressWarnings("unused")
private VotingPluginMain plugin;
private VotingPluginUser user;
public VoteBest(VotingPluginMain plugin, CommandSender player, VotingPluginUser user) {
super(player);
this.plugin = plugin;
this.user = user;
}
@Override
public ArrayList<String> getChat(CommandSender sender) {
ArrayList<String> msg = new ArrayList<String>();
msg.add(plugin.getConfigFile().getFormatCommandsVoteBestTitle());
msg.addAll(plugin.getConfigFile().getFormatCommandsVoteBestLines());
HashMap<String, String> placeholders = new HashMap<String, String>();
placeholders.put("HighestDailyTotal", "" + user.getHighestDailyTotal());
placeholders.put("HighestWeeklyTotal", "" + user.getHighestWeeklyTotal());
placeholders.put("HighestMonthlyTotal", "" + user.getHighestMonthlyTotal());
placeholders.put("player", user.getPlayerName());
msg = ArrayUtils.getInstance().replacePlaceHolder(msg, placeholders);
return ArrayUtils.getInstance().colorize(msg);
}
@Override
public void onBook(Player player) {
// TODO
}
@Override
public void onChat(CommandSender sender) {
sendMessage(getChat(sender));
}
@Override
public void onChest(Player player) {
BInventory inv = new BInventory(plugin.getGui().getChestVoteBestName());
inv.addPlaceholder("player", user.getPlayerName());
inv.addButton(new BInventoryButton(new ItemBuilder(plugin.getGui().getChestVoteBestDayBestItem())
.addPlaceholder("Best", "" + user.getBestDayVoteStreak())) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(plugin.getGui().getChestVoteBestWeekBestItem())
.addPlaceholder("Best", "" + user.getBestWeekVoteStreak())) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(plugin.getGui().getChestVoteBestMonthBestItem())
.addPlaceholder("Best", "" + user.getBestMonthVoteStreak())) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.valueOf(plugin.getGui().getGuiMethodBest().toUpperCase()));
}
}
@@ -0,0 +1,206 @@
package com.bencodez.votingplugin.commands.gui.player;
import java.util.ArrayList;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.UpdatingBInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.misc.ArrayUtils;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import com.bencodez.advancedcore.api.rewards.RewardOptions;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.topvoter.TopVoter;
import com.bencodez.votingplugin.user.UserManager;
import com.bencodez.votingplugin.user.VotingPluginUser;
public class VoteGUI extends GUIHandler {
private VotingPluginMain plugin;
private VotingPluginUser user;
public VoteGUI(VotingPluginMain plugin, CommandSender player, VotingPluginUser user) {
super(player);
this.plugin = plugin;
this.user = user;
}
@Override
public ArrayList<String> getChat(CommandSender arg0) {
return null;
}
private ItemBuilder getItemSlot(String slot, Player player) {
ItemBuilder builder = new ItemBuilder(plugin.getGui().getChestVoteGUISlotSection(slot));
String[] lore = new String[1];
lore = ArrayUtils.getInstance().convert(plugin.getGui().getChestVoteGUISlotLore(slot));
String str = plugin.getConfigFile().getVoteTopDefault();
if (lore.length == 0) {
if (slot.equalsIgnoreCase("url")) {
lore = new String[] { "&aClick me" };
} else if (slot.equalsIgnoreCase("next")) {
lore = ArrayUtils.getInstance().convert(new VoteNext(plugin, player, user).getChat(player));
} else if (slot.equalsIgnoreCase("last")) {
lore = ArrayUtils.getInstance().convert(new VoteLast(plugin, player, user).getChat(player));
} else if (slot.equalsIgnoreCase("total")) {
lore = ArrayUtils.getInstance().convert(new VoteTotal(plugin, player, user).getChat(player));
} else if (slot.equalsIgnoreCase("top")) {
if (str.equalsIgnoreCase("monthly")) {
lore = plugin.getTopVoterHandler().topVoterMonthly(1);
} else if (str.equalsIgnoreCase("weekly")) {
lore = plugin.getTopVoterHandler().topVoterWeekly(1);
} else if (str.equalsIgnoreCase("daily")) {
lore = plugin.getTopVoterHandler().topVoterDaily(1);
} else {
lore = plugin.getTopVoterHandler().topVoterAllTime(1);
}
} else if (slot.equalsIgnoreCase("today")) {
String[] today = new VoteToday(plugin, player, user, 1).voteTodayGUI();
ArrayList<String> list = new ArrayList<String>();
if (today.length > 0) {
for (int i = today.length - 1; i < today.length && list.size() < 10 && i >= 0; i--) {
list.add(today[i]);
}
}
lore = ArrayUtils.getInstance().convert(list);
} else if (slot.equalsIgnoreCase("help")) {
lore = new String[] { "Click to view help" };
}
}
builder.setLore(ArrayUtils.getInstance().convert(lore));
return builder;
}
@Override
public void onBook(Player player) {
/*
* BookWrapper book = new
* BookWrapper(plugin.getGui().getBookVoteURLBookGUITitle());
*
* // url - click to open Layout urlLayout = new Layout(new
* ArrayList<String>(Arrays.asList("[Json]")));
* urlLayout.replaceTextComponent("[Json]",
* BookUtil.TextBuilder.of(book.colorize("Click me")).onClick(BookUtil.
* ClickAction.runCommand("/vote url"))
* .onHover(BookUtil.HoverAction.showText("Clicking me opens url GUI")).build())
* ; book.addLayout(urlLayout); book.addLine();
*
* // next - click to open for (VoteSite site : plugin.getVoteSites()) { Layout
* nextLayout = new Layout(new ArrayList<String>(Arrays.asList("[Json]")));
* nextLayout.replaceTextComponent("[Json]",
* BookUtil.TextBuilder.of(site.getDisplayName())
* .onClick(BookUtil.ClickAction.openUrl(site.getVoteURLJsonStrip()))
* .onHover(BookUtil.HoverAction.showText(user.voteCommandNextInfo(site))).build
* ()); book.addLayout(nextLayout); } book.addLine();
*
* // total - click to open
*
* // top = click to open
*
* // today - click to open
*
* // shop - click to open
*
* book.open(player);
*/
}
@Override
public void onChat(CommandSender sender) {
// not available
}
@Override
public void onChest(Player player) {
if (this.user == null) {
user = UserManager.getInstance().getVotingPluginUser((Player) player);
}
BInventory inv = new BInventory(plugin.getGui().getChestVoteGUIName());
if (!plugin.getConfigFile().isAlwaysCloseInventory()) {
inv.dontClose();
}
inv.addPlaceholder("points", "" + user.getPoints());
inv.addPlaceholder("player", user.getPlayerName());
inv.addPlaceholder("top", plugin.getConfigFile().getVoteTopDefault());
for (String slot : plugin.getGui().getChestVoteGUISlots()) {
ItemBuilder builder = getItemSlot(slot, player);
inv.addButton(new UpdatingBInventoryButton(builder, 1000, 1000) {
@Override
public void onClick(ClickEvent event) {
Player player = event.getWhoClicked();
String cmd = plugin.getGui().getChestVoteGUISlotCommand(slot);
if (cmd.equalsIgnoreCase("none")) {
return;
} else if (!cmd.equals("")) {
event.runSync(new Runnable() {
@Override
public void run() {
player.performCommand(cmd);
}
});
} else {
if (slot.equalsIgnoreCase("url")) {
new VoteURL(plugin, player, user, true).open();
} else if (slot.equalsIgnoreCase("next")) {
new VoteNext(plugin, player, user).open(GUIMethod.CHEST);
} else if (slot.equalsIgnoreCase("last")) {
new VoteLast(plugin, player, user).open(GUIMethod.CHEST);
} else if (slot.equalsIgnoreCase("total")) {
new VoteTotal(plugin, player, user).open(GUIMethod.CHEST);
} else if (slot.equalsIgnoreCase("top")) {
new VoteTopVoter(plugin, player, user, TopVoter.getDefault(), 1).open(GUIMethod.CHEST);
} else if (slot.equalsIgnoreCase("today")) {
new VoteToday(plugin, player, user, 1).open(GUIMethod.CHEST);
} else if (slot.equalsIgnoreCase("help")) {
player.performCommand("vote help");
} else if (slot.equalsIgnoreCase("shop")) {
new VoteShop(plugin, player, user).open(GUIMethod.CHEST);
} else if (slot.equalsIgnoreCase("lastmonth")) {
new VoteTopVoterLastMonth(plugin, player, user).open(GUIMethod.CHEST);
}
}
if (RewardHandler.getInstance().hasRewards(plugin.getGui().getData(),
plugin.getGui().getChestVoteGUISlotRewardsPath(slot))) {
RewardHandler.getInstance().giveReward(UserManager.getInstance().getVotingPluginUser(player),
plugin.getGui().getData(), plugin.getGui().getChestVoteGUISlotRewardsPath(slot),
new RewardOptions().addPlaceholder("identifier", slot));
}
}
@Override
public ItemBuilder onUpdate(Player player) {
ItemBuilder item = getItemSlot(slot, player);
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(player);
item.addPlaceholder("points", "" + user.getPoints());
item.addPlaceholder("player", user.getPlayerName());
item.addPlaceholder("top", plugin.getConfigFile().getVoteTopDefault());
return item;
}
});
}
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.valueOf(plugin.getGui().getGuiMethodGUI().toUpperCase()));
}
}
@@ -0,0 +1,96 @@
package com.bencodez.votingplugin.commands.gui.player;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.command.CommandHandler;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.messages.StringParser;
import com.bencodez.votingplugin.VotingPluginMain;
import net.md_5.bungee.api.chat.TextComponent;
public class VoteHelp extends GUIHandler {
private int page;
private VotingPluginMain plugin;
public VoteHelp(VotingPluginMain plugin, CommandSender player, int page) {
super(player);
this.plugin = plugin;
this.page = page;
}
@Override
public ArrayList<String> getChat(CommandSender sender) {
return null;
}
public ArrayList<TextComponent> helpText(CommandSender sender) {
ArrayList<TextComponent> msg = new ArrayList<TextComponent>();
HashMap<String, TextComponent> unsorted = new HashMap<String, TextComponent>();
boolean requirePerms = plugin.getConfigFile().getFormatCommandsVoteHelpRequirePermission();
for (CommandHandler cmdHandle : plugin.getVoteCommand()) {
if (!requirePerms || cmdHandle.hasPerm(sender)) {
unsorted.put(cmdHandle.getHelpLineCommand("/vote"),
cmdHandle.getHelpLine("/vote", plugin.getConfigFile().getFormatCommandsVoteHelpLine()));
}
}
ArrayList<String> unsortedList = new ArrayList<String>();
unsortedList.addAll(unsorted.keySet());
Collections.sort(unsortedList, String.CASE_INSENSITIVE_ORDER);
for (String cmd : unsortedList) {
msg.add(unsorted.get(cmd));
}
return msg;
}
@Override
public void onBook(Player player) {
}
@Override
public void onChat(CommandSender sender) {
sendMessageJson(voteHelpText(sender));
}
@Override
public void onChest(Player player) {
}
@Override
public void open() {
open(GUIMethod.CHAT);
}
public ArrayList<TextComponent> voteHelpText(CommandSender sender) {
int pagesize = plugin.getConfigFile().getFormatPageSize();
ArrayList<TextComponent> msg = new ArrayList<TextComponent>();
ArrayList<TextComponent> text = helpText(sender);
int maxPage = text.size() / pagesize;
if ((text.size() % pagesize) != 0) {
maxPage++;
}
msg.add(StringParser.getInstance()
.stringToComp(plugin.getConfigFile().getFormatCommandsVoteHelpTitle() + " " + page + "/" + maxPage));
for (int i = pagesize * (page - 1); (i < text.size()) && (i < ((page) * pagesize)); i++) {
msg.add(text.get(i));
}
return msg;
}
}
@@ -0,0 +1,95 @@
package com.bencodez.votingplugin.commands.gui.player;
import java.util.ArrayList;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.UpdatingBInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.messages.StringParser;
import com.bencodez.advancedcore.api.misc.ArrayUtils;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.objects.VoteSite;
import com.bencodez.votingplugin.user.VotingPluginUser;
public class VoteLast extends GUIHandler {
private VotingPluginMain plugin;
private VotingPluginUser user;
public VoteLast(VotingPluginMain plugin, CommandSender player, VotingPluginUser user) {
super(player);
this.plugin = plugin;
this.user = user;
}
@Override
public ArrayList<String> getChat(CommandSender sender) {
ArrayList<String> msg = new ArrayList<String>();
String playerName = user.getPlayerName();
msg.add(StringParser.getInstance().replaceIgnoreCase(plugin.getConfigFile().getFormatCommandsVoteLastTitle(),
"%player%", playerName));
for (VoteSite voteSite : plugin.getVoteSites()) {
if (!voteSite.isHidden()) {
msg.add(user.voteCommandLastLine(voteSite));
}
}
return ArrayUtils.getInstance().colorize(msg);
}
@Override
public void onBook(Player player) {
// TODO
}
@Override
public void onChat(CommandSender sender) {
sendMessage(getChat(sender));
}
@Override
public void onChest(Player player) {
BInventory inv = new BInventory(plugin.getGui().getChestVoteLastName());
inv.addPlaceholder("player", user.getPlayerName());
for (VoteSite site : plugin.getVoteSites()) {
if (!site.isHidden()) {
inv.addButton(inv.getNextSlot(),
new UpdatingBInventoryButton(site.getItem().setName(site.getDisplayName())
.setLore(user.voteCommandLastLine(site)).setAmountNone(1), 1000, 1000) {
@Override
public void onClick(ClickEvent clickEvent) {
}
@Override
public ItemBuilder onUpdate(Player p) {
return site.getItem().setName(site.getDisplayName())
.setLore(user.voteCommandLastLine(site)).setAmountNone(1);
}
});
}
}
if (plugin.getGui().getChestVoteLastBackButton()) {
inv.addButton(plugin.getCommandLoader().getBackButton(user));
}
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.valueOf(plugin.getGui().getGuiMethodLast().toUpperCase()));
}
}
@@ -0,0 +1,115 @@
package com.bencodez.votingplugin.commands.gui.player;
import java.util.ArrayList;
import java.util.Arrays;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.bookgui.BookWrapper;
import com.bencodez.advancedcore.api.bookgui.Layout;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.UpdatingBInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.messages.StringParser;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.objects.VoteSite;
import com.bencodez.votingplugin.user.VotingPluginUser;
import xyz.upperlevel.spigot.book.BookUtil;
public class VoteNext extends GUIHandler {
private VotingPluginMain plugin;
private VotingPluginUser user;
public VoteNext(VotingPluginMain plugin, CommandSender player, VotingPluginUser user) {
super(player);
this.plugin = plugin;
this.user = user;
}
@Override
public ArrayList<String> getChat(CommandSender sender) {
ArrayList<String> msg = new ArrayList<String>();
String playerName = user.getPlayerName();
msg.add(StringParser.getInstance().colorize(StringParser.getInstance()
.replaceIgnoreCase(plugin.getConfigFile().getFormatCommandsVoteNextTitle(), "%player%", playerName)));
for (VoteSite voteSite : plugin.getVoteSites()) {
if (!voteSite.isHidden()) {
String msgLine = plugin.getConfigFile().getFormatCommandsVoteNextLayout();
msgLine = StringParser.getInstance().replaceIgnoreCase(msgLine, "%info%",
user.voteCommandNextInfo(voteSite));
msgLine = StringParser.getInstance().replaceIgnoreCase(msgLine, "%SiteName%",
voteSite.getDisplayName());
msg.add(StringParser.getInstance().colorize(msgLine));
}
}
return msg;
}
@Override
public void onBook(Player player) {
BookWrapper book = new BookWrapper(plugin.getGui().getBookVoteURLBookGUITitle());
// add colors/config options
for (VoteSite site : plugin.getVoteSites()) {
Layout nextLayout = new Layout(new ArrayList<String>(Arrays.asList("[Json]")));
nextLayout.replaceTextComponent("[Json]",
BookUtil.TextBuilder.of(book.colorize(site.getDisplayName()))
.onClick(BookUtil.ClickAction.openUrl(site.getVoteURLJsonStrip()))
.onHover(BookUtil.HoverAction.showText(user.voteCommandNextInfo(site))).build());
book.addLayout(nextLayout);
}
book.addLine();
book.open(player);
}
@Override
public void onChat(CommandSender sender) {
sendMessage(getChat(sender));
}
@Override
public void onChest(Player player) {
BInventory inv = new BInventory(plugin.getGui().getChestVoteNextName());
inv.addPlaceholder("player", user.getPlayerName());
for (VoteSite site : plugin.getVoteSites()) {
inv.addButton(inv.getNextSlot(), new UpdatingBInventoryButton(site.getItem().setName(site.getDisplayName())
.setLore(user.voteCommandNextInfo(site)).setAmountNone(1), 1000, 1000) {
@Override
public void onClick(ClickEvent clickEvent) {
}
@Override
public ItemBuilder onUpdate(Player player) {
return site.getItem().setName(site.getDisplayName()).setLore(user.voteCommandNextInfo(site))
.setAmountNone(1).addPlaceholder("player", user.getPlayerName());
}
});
}
if (plugin.getGui().getChestVoteNextBackButton()) {
inv.addButton(plugin.getCommandLoader().getBackButton(user));
}
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.valueOf(plugin.getGui().getGuiMethodNext().toUpperCase()));
}
}
@@ -0,0 +1,170 @@
package com.bencodez.votingplugin.commands.gui.player;
import java.util.ArrayList;
import java.util.HashMap;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.messages.StringParser;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import com.bencodez.advancedcore.api.rewards.RewardOptions;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.user.UserManager;
import com.bencodez.votingplugin.user.VotingPluginUser;
public class VoteShop extends GUIHandler {
private VotingPluginMain plugin;
private VotingPluginUser user;
public VoteShop(VotingPluginMain plugin, CommandSender player, VotingPluginUser user) {
super(player);
this.plugin = plugin;
this.user = user;
}
@Override
public ArrayList<String> getChat(CommandSender arg0) {
return null;
}
@Override
public void onBook(Player player) {
}
@Override
public void onChat(CommandSender sender) {
}
@Override
public void onChest(Player player) {
if (!plugin.getGui().getChestVoteShopEnabled()) {
player.sendMessage(StringParser.getInstance().colorize(plugin.getGui().getChestVoteShopDisabled()));
return;
}
BInventory inv = new BInventory(plugin.getGui().getChestVoteShopName());
inv.dontClose();
for (final String identifier : plugin.getGui().getChestShopIdentifiers()) {
String perm = plugin.getGui().getChestVoteShopPermission(identifier);
boolean hasPerm = false;
if (perm.isEmpty()) {
hasPerm = true;
} else {
hasPerm = player.hasPermission(perm);
}
int limit = plugin.getGui().getChestShopIdentifierLimit(identifier);
boolean limitPass = true;
if (limit > 0) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(player);
if (user.getVoteShopIdentifierLimit(identifier) >= limit) {
limitPass = false;
}
}
if (!plugin.getGui().getChestVoteShopNotBuyable(identifier)) {
if (hasPerm && (limitPass || !plugin.getGui().isChestVoteShopHideLimitedReached())) {
ItemBuilder builder = new ItemBuilder(plugin.getGui().getChestShopIdentifierSection(identifier));
inv.addButton(new BInventoryButton(builder) {
@Override
public void onClick(ClickEvent event) {
Player player = event.getWhoClicked();
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(player);
if (plugin.getConfigFile().isClearCacheOnVoteShopPurchase()
|| plugin.getBungeeSettings().isUseBungeecoord()) {
user.clearCache();
}
String identifier = (String) getData("identifier");
int limit = (int) getData("Limit");
int points = plugin.getGui().getChestShopIdentifierCost(identifier);
if (identifier != null) {
if (plugin.getGui().getChestVoteShopCloseGUI(identifier)) {
event.getButton().getInv().closeInv(player, null);
}
// limit fail-safe, should never be needed, except in rare cases
boolean limitPass = true;
if (limit > 0) {
if (user.getVoteShopIdentifierLimit(identifier) >= limit) {
limitPass = false;
}
}
if (limitPass) {
if (!plugin.getGui().isChestVoteShopRequireConfirmation(identifier)) {
HashMap<String, String> placeholders = new HashMap<String, String>();
placeholders.put("identifier",
plugin.getGui().getChestShopIdentifierIdentifierName(identifier));
placeholders.put("points", "" + points);
placeholders.put("limit", "" + limit);
if (user.removePoints(points)) {
RewardHandler.getInstance().giveReward(user, plugin.getGui().getData(),
plugin.getGui().getChestShopIdentifierRewardsPath(identifier),
new RewardOptions().setPlaceholders(placeholders));
user.sendMessage(StringParser.getInstance().replacePlaceHolder(
plugin.getGui().getCHESTVoteShopPurchase(identifier), placeholders));
if (limit > 0) {
user.setVoteShopIdentifierLimit(identifier,
user.getVoteShopIdentifierLimit(identifier) + 1);
}
} else {
user.sendMessage(StringParser.getInstance().replacePlaceHolder(
plugin.getConfigFile().getFormatShopFailedMsg(), placeholders));
}
} else {
new VoteShopConfirm(plugin, player, user, identifier).open(GUIMethod.CHEST);
;
}
} else {
user.sendMessage(plugin.getGui().getChestVoteShopLimitReached());
}
}
}
}.addData("identifier", identifier).addData("Limit", limit));
}
} else {
if (hasPerm) {
ItemBuilder builder = new ItemBuilder(plugin.getGui().getChestShopIdentifierSection(identifier));
inv.addButton(new BInventoryButton(builder) {
@Override
public void onClick(ClickEvent event) {
}
}.dontClose().addData("identifier", identifier).addData("Limit", limit));
}
}
}
if (plugin.getGui().getChestVoteShopBackButton()) {
inv.addButton(plugin.getCommandLoader().getBackButton(user));
}
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.CHEST);
}
}
@@ -0,0 +1,104 @@
package com.bencodez.votingplugin.commands.gui.player;
import java.util.ArrayList;
import java.util.HashMap;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.messages.StringParser;
import com.bencodez.advancedcore.api.misc.PlayerUtils;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import com.bencodez.advancedcore.api.rewards.RewardOptions;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.user.VotingPluginUser;
public class VoteShopConfirm extends GUIHandler {
private String identifier;
private VotingPluginMain plugin;
private VotingPluginUser user;
public VoteShopConfirm(VotingPluginMain plugin, CommandSender player, VotingPluginUser user, String identifier) {
super(player);
this.plugin = plugin;
this.user = user;
this.identifier = identifier;
}
@Override
public ArrayList<String> getChat(CommandSender arg0) {
return null;
}
@Override
public void onBook(Player player) {
}
@Override
public void onChat(CommandSender sender) {
}
@Override
public void onChest(Player player) {
PlayerUtils.getInstance().setPlayerMeta(player, "ident", identifier);
BInventory inv = new BInventory(plugin.getGui().getChestShopConfirmPurchaseTitle());
inv.addButton(new BInventoryButton(new ItemBuilder(plugin.getGui().getChestShopConfirmPurchaseYesItem())) {
@Override
public void onClick(ClickEvent event) {
int points = plugin.getGui().getChestShopIdentifierCost(identifier);
int limit = plugin.getGui().getChestShopIdentifierLimit(identifier);
HashMap<String, String> placeholders = new HashMap<String, String>();
placeholders.put("identifier", identifier);
placeholders.put("points", "" + points);
placeholders.put("limit", "" + limit);
if (user.removePoints(points)) {
RewardHandler.getInstance().giveReward(user, plugin.getGui().getData(),
plugin.getGui().getChestShopIdentifierRewardsPath(identifier),
new RewardOptions().setPlaceholders(placeholders));
user.sendMessage(StringParser.getInstance()
.replacePlaceHolder(plugin.getGui().getCHESTVoteShopPurchase(identifier), placeholders));
if (limit > 0) {
user.setVoteShopIdentifierLimit(identifier, user.getVoteShopIdentifierLimit(identifier) + 1);
}
} else {
user.sendMessage(StringParser.getInstance()
.replacePlaceHolder(plugin.getConfigFile().getFormatShopFailedMsg(), placeholders));
}
if (plugin.getGui().getChestVoteShopCloseGUI(identifier)) {
event.getButton().getInv().closeInv(player, null);
} else {
new VoteShop(plugin, event.getPlayer(), user);
}
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(plugin.getGui().getChestShopConfirmPurchaseNoItem())) {
@Override
public void onClick(ClickEvent event) {
if (plugin.getGui().getChestVoteShopCloseGUI(identifier)) {
event.getButton().getInv().closeInv(player, null);
} else {
new VoteShop(plugin, event.getPlayer(), user);
}
}
});
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.CHEST);
}
}
@@ -0,0 +1,134 @@
package com.bencodez.votingplugin.commands.gui.player;
import java.util.ArrayList;
import java.util.HashMap;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.misc.ArrayUtils;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.user.VotingPluginUser;
public class VoteStreak extends GUIHandler {
@SuppressWarnings("unused")
private VotingPluginMain plugin;
private VotingPluginUser user;
public VoteStreak(VotingPluginMain plugin, CommandSender player, VotingPluginUser user) {
super(player);
this.plugin = plugin;
this.user = user;
}
@Override
public ArrayList<String> getChat(CommandSender sender) {
ArrayList<String> msg = new ArrayList<String>();
msg.add(plugin.getConfigFile().getFormatCommandsVoteStreakTitle());
msg.addAll(plugin.getConfigFile().getFormatCommandsVoteStreakLines());
HashMap<String, String> placeholders = new HashMap<String, String>();
placeholders.put("DailyStreak", "" + user.getDayVoteStreak());
placeholders.put("WeeklyStreak", "" + user.getWeekVoteStreak());
placeholders.put("MonthlyStreak", "" + user.getMonthVoteStreak());
placeholders.put("BestDailyStreak", "" + user.getBestDayVoteStreak());
placeholders.put("BestWeeklyStreak", "" + user.getBestWeekVoteStreak());
placeholders.put("BestMonthlyStreak", "" + user.getBestMonthVoteStreak());
placeholders.put("player", user.getPlayerName());
msg = ArrayUtils.getInstance().replacePlaceHolder(msg, placeholders);
return ArrayUtils.getInstance().colorize(msg);
}
@Override
public void onBook(Player player) {
// TODO
}
@Override
public void onChat(CommandSender sender) {
sendMessage(getChat(sender));
}
@Override
public void onChest(Player player) {
BInventory inv = new BInventory(plugin.getGui().getChestVoteStreakName());
inv.addPlaceholder("player", user.getPlayerName());
inv.addButton(new BInventoryButton(new ItemBuilder(plugin.getGui().getChestVoteStreakCurrentDayStreakItem())
.addPlaceholder("Streak", "" + user.getDayVoteStreak())) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(plugin.getGui().getChestVoteStreakCurrentWeekStreakItem())
.addPlaceholder("Streak", "" + user.getWeekVoteStreak())) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(plugin.getGui().getChestVoteStreakCurrentMonthStreakItem())
.addPlaceholder("Streak", "" + user.getMonthVoteStreak())) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(plugin.getGui().getChestVoteStreakHighestDayStreakItem())
.addPlaceholder("Streak", "" + user.getBestDayVoteStreak())) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(plugin.getGui().getChestVoteStreakHighestWeekStreakItem())
.addPlaceholder("Streak", "" + user.getBestWeekVoteStreak())) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
inv.addButton(new BInventoryButton(new ItemBuilder(plugin.getGui().getChestVoteStreakHighestMonthStreakItem())
.addPlaceholder("Streak", "" + user.getBestMonthVoteStreak())) {
@Override
public void onClick(ClickEvent clickEvent) {
}
});
if (plugin.getGui().getChestVoteStreakBackButton()) {
inv.addButton(plugin.getCommandLoader().getBackButton(user));
}
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.valueOf(plugin.getGui().getGuiMethodStreak().toUpperCase()));
}
}
@@ -0,0 +1,178 @@
package com.bencodez.votingplugin.commands.gui.player;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map.Entry;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.messages.StringParser;
import com.bencodez.advancedcore.api.misc.ArrayUtils;
import com.bencodez.advancedcore.api.user.UUID;
import com.bencodez.advancedcore.nms.NMSManager;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.objects.VoteSite;
import com.bencodez.votingplugin.user.UserManager;
import com.bencodez.votingplugin.user.VotingPluginUser;
public class VoteToday extends GUIHandler {
private int page;
private VotingPluginMain plugin;
private VotingPluginUser user;
public VoteToday(VotingPluginMain plugin, CommandSender player, VotingPluginUser user, int page) {
super(player);
this.plugin = plugin;
this.user = user;
this.page = page;
}
@Override
public ArrayList<String> getChat(CommandSender arg0) {
int pagesize = plugin.getConfigFile().getFormatPageSize();
if (page < 1) {
page = 1;
}
ArrayList<String> msg = new ArrayList<String>();
String[] voteToday = voteToday();
int maxPage = voteToday.length / pagesize;
if ((voteToday.length % pagesize) != 0) {
maxPage++;
}
HashMap<String, String> placeholders = new HashMap<String, String>();
placeholders.put("page", "" + page);
placeholders.put("maxpage", "" + maxPage);
for (String m : plugin.getConfigFile().getFormatCommandsVoteTodayTitle()) {
msg.add(m);
}
page--;
for (int i = pagesize * page; (i < voteToday.length) && (i < ((page + 1) * pagesize)); i++) {
msg.add(voteToday[i]);
}
return ArrayUtils.getInstance().colorize(ArrayUtils.getInstance().replacePlaceHolder(msg, placeholders));
}
@Override
public void onBook(Player player) {
// TODO
}
@Override
public void onChat(CommandSender sender) {
sendMessage(getChat(sender));
}
@Override
public void onChest(Player player) {
BInventory inv = new BInventory(plugin.getGui().getChestVoteTodayName());
if (!plugin.getConfigFile().isAlwaysCloseInventory()) {
inv.dontClose();
}
for (VotingPluginUser user : plugin.getVoteToday().keySet()) {
for (VoteSite voteSite : plugin.getVoteToday().get(user).keySet()) {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(plugin.getConfigFile().getFormatTimeFormat());
String timeString = plugin.getVoteToday().get(user).get(voteSite).format(formatter);
String msg = plugin.getGui().getChestVoteTodayLine();
HashMap<String, String> placeholders = new HashMap<String, String>();
placeholders.put("VoteSite", voteSite.getDisplayName());
placeholders.put("Time", timeString);
msg = StringParser.getInstance().replacePlaceHolder(msg, placeholders);
ItemBuilder item = null;
if (plugin.getGui().isChestVoteTodayUseSkull() && !NMSManager.getInstance().isVersion("1.12")) {
item = new ItemBuilder(user.getPlayerHead());
} else {
item = new ItemBuilder(plugin.getGui().getChestVoteTodayPlayerItem());
}
item.setName(StringParser.getInstance().replacePlaceHolder(plugin.getGui().getChestVoteTodayIconTitle(),
"player", user.getPlayerName()));
item.setLore(msg);
final String uuid = user.getUUID();
inv.addButton(inv.getNextSlot(), new BInventoryButton(item) {
@Override
public void onClick(ClickEvent clickEvent) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
new VoteGUI(plugin, player, user)
.open(GUIMethod.valueOf(plugin.getGui().getGuiMethodGUI().toUpperCase()));
}
});
}
}
if (plugin.getGui().getChestVoteTodayBackButton()) {
inv.addButton(plugin.getCommandLoader().getBackButton(user));
}
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.valueOf(plugin.getGui().getGuiMethodToday().toUpperCase()));
}
public String[] voteToday() {
ArrayList<String> msg = new ArrayList<String>();
for (VotingPluginUser user : plugin.getVoteToday().keySet()) {
for (VoteSite voteSite : plugin.getVoteToday().get(user).keySet()) {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(plugin.getConfigFile().getFormatTimeFormat());
String timeString = plugin.getVoteToday().get(user).get(voteSite).format(formatter);
HashMap<String, String> placeholders = new HashMap<String, String>();
placeholders.put("player", user.getPlayerName());
placeholders.put("votesite", voteSite.getKey());
placeholders.put("time", timeString);
msg.add(StringParser.getInstance()
.replacePlaceHolder(plugin.getConfigFile().getFormatCommandsVoteTodayLine(), placeholders));
// msg.add("&6" + user.getPlayerName() + " : " + voteSite.getKey() + " : " +
// timeString);
}
}
msg = ArrayUtils.getInstance().colorize(msg);
return ArrayUtils.getInstance().convert(msg);
}
public String[] voteTodayGUI() {
ArrayList<String> msg = new ArrayList<String>();
for (VotingPluginUser user : plugin.getVoteToday().keySet()) {
LocalDateTime mostRecent = null;
VoteSite mostRecentSite = null;
for (Entry<VoteSite, LocalDateTime> entry : plugin.getVoteToday().get(user).entrySet()) {
if (mostRecent == null || entry.getValue().isAfter(mostRecent)) {
mostRecent = entry.getValue();
mostRecentSite = entry.getKey();
}
}
if (mostRecent != null) {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(plugin.getConfigFile().getFormatTimeFormat());
String timeString = mostRecent.format(formatter);
HashMap<String, String> placeholders = new HashMap<String, String>();
placeholders.put("player", user.getPlayerName());
placeholders.put("votesite", mostRecentSite.getKey());
placeholders.put("time", timeString);
msg.add(StringParser.getInstance()
.replacePlaceHolder(plugin.getConfigFile().getFormatCommandsVoteTodayLine(), placeholders));
}
}
msg = ArrayUtils.getInstance().colorize(msg);
return ArrayUtils.getInstance().convert(msg);
}
}
@@ -0,0 +1,148 @@
package com.bencodez.votingplugin.commands.gui.player;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.Map.Entry;
import java.util.Set;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.ClickType;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.misc.ArrayUtils;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.topvoter.TopVoter;
import com.bencodez.votingplugin.user.VotingPluginUser;
public class VoteTopVoter extends GUIHandler {
private int page;
private VotingPluginMain plugin;
private TopVoter top;
private VotingPluginUser user;
public VoteTopVoter(VotingPluginMain plugin, CommandSender player, VotingPluginUser user, TopVoter top, int page) {
super(player);
this.plugin = plugin;
this.user = user;
this.top = top;
this.page = page;
}
@Override
public ArrayList<String> getChat(CommandSender sender) {
switch (top) {
case AllTime:
return ArrayUtils.getInstance().convert(plugin.getTopVoterHandler().topVoterAllTime(page));
case Daily:
return ArrayUtils.getInstance().convert(plugin.getTopVoterHandler().topVoterDaily(page));
case Monthly:
return ArrayUtils.getInstance().convert(plugin.getTopVoterHandler().topVoterMonthly(page));
case Weekly:
return ArrayUtils.getInstance().convert(plugin.getTopVoterHandler().topVoterWeekly(page));
default:
break;
}
return new ArrayList<String>();
}
@Override
public void onBook(Player player) {
// TODO
}
@Override
public void onChat(CommandSender sender) {
sendMessage(getChat(sender));
}
@Override
public void onChest(Player player) {
try {
if (top == null) {
top = TopVoter.getDefault();
}
Set<Entry<VotingPluginUser, Integer>> users = null;
String topVoter = top.getName();
@SuppressWarnings("unchecked")
LinkedHashMap<VotingPluginUser, Integer> topVotes = (LinkedHashMap<VotingPluginUser, Integer>) plugin
.getTopVoter(top).clone();
users = topVotes.entrySet();
BInventory inv = new BInventory(plugin.getGui().getChestVoteTopName());
inv.addPlaceholder("topvoter", topVoter);
if (!plugin.getConfigFile().isAlwaysCloseInventory()) {
inv.dontClose();
}
int pos = 1;
for (Entry<VotingPluginUser, Integer> entry : users) {
ItemBuilder playerItem;
if (plugin.getGui().isChestVoteTopUseSkull()) {
playerItem = new ItemBuilder(entry.getKey().getPlayerHead());
} else {
playerItem = new ItemBuilder(Material.valueOf(plugin.getGui().getChestVoteTopPlayerItemMaterial()));
}
playerItem.setLore(new ArrayList<String>());
inv.addButton(new BInventoryButton(playerItem.setName(plugin.getGui().getChestVoteTopItemName())
.addLoreLine(plugin.getGui().getChestVoteTopItemLore()).addPlaceholder("position", "" + pos)
.addPlaceholder("player", entry.getKey().getPlayerName())
.addPlaceholder("votes", "" + entry.getValue())) {
@Override
public void onClick(ClickEvent clickEvent) {
if (plugin.getGui().getChestVoteTopOpenMainGUIOnClick()) {
VotingPluginUser user = (VotingPluginUser) getData("User");
new VoteGUI(plugin, player, user)
.open(GUIMethod.valueOf(plugin.getGui().getGuiMethodGUI().toUpperCase()));
} else {
getInv().forceClose(clickEvent.getPlayer());
}
}
}.addData("player", entry.getKey().getPlayerName()).addData("User", entry.getKey()));
pos++;
}
final TopVoter cur = top;
inv.getPageButtons().add(new BInventoryButton(
new ItemBuilder(plugin.getGui().getChestVoteTopSwitchItem()).addPlaceholder("Top", topVoter)) {
@Override
public void onClick(ClickEvent clickEvent) {
if (!clickEvent.getClick().equals(ClickType.RIGHT)) {
new VoteTopVoter(plugin, player, user, cur.next(), 0).open(GUIMethod.CHEST);
} else {
new VoteTopVoter(plugin, player, user, cur.prev(), 0).open(GUIMethod.CHEST);
}
}
});
if (plugin.getGui().getChestVoteTopBackButton()) {
inv.getPageButtons().add(plugin.getCommandLoader().getBackButton(user).setSlot(1));
}
inv.setPages(true);
inv.setMaxInvSize(plugin.getGui().getChestVoteTopSize());
inv.openInventory(player);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void open() {
open(GUIMethod.valueOf(plugin.getGui().getGuiMethodTopVoter().toUpperCase()));
}
}
@@ -0,0 +1,98 @@
package com.bencodez.votingplugin.commands.gui.player;
import java.util.ArrayList;
import java.util.Map.Entry;
import java.util.Set;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.user.VotingPluginUser;
public class VoteTopVoterLastMonth extends GUIHandler {
private VotingPluginMain plugin;
private VotingPluginUser user;
public VoteTopVoterLastMonth(VotingPluginMain plugin, CommandSender player, VotingPluginUser user) {
super(player);
this.plugin = plugin;
this.user = user;
}
@Override
public ArrayList<String> getChat(CommandSender arg0) {
return null;
}
@Override
public void onBook(Player player) {
// TODO
}
@Override
public void onChat(CommandSender sender) {
}
@Override
public void onChest(Player player) {
Set<Entry<VotingPluginUser, Integer>> users = null;
users = plugin.getLastMonthTopVoter().entrySet();
BInventory inv = new BInventory(plugin.getGui().getChestVoteTopName());
inv.addPlaceholder("topvoter", "Last Month");
if (!plugin.getConfigFile().isAlwaysCloseInventory()) {
inv.dontClose();
}
int pos = 1;
for (Entry<VotingPluginUser, Integer> entry : users) {
ItemBuilder playerItem;
if (plugin.getGui().isChestVoteTopUseSkull()) {
playerItem = new ItemBuilder(entry.getKey().getPlayerHead());
} else {
playerItem = new ItemBuilder(Material.valueOf(plugin.getGui().getChestVoteTopPlayerItemMaterial()));
}
playerItem.setLore(new ArrayList<String>());
inv.addButton(new BInventoryButton(playerItem.setName(plugin.getGui().getChestVoteTopItemName())
.addLoreLine(plugin.getGui().getChestVoteTopItemLore()).addPlaceholder("position", "" + pos)
.addPlaceholder("player", entry.getKey().getPlayerName())
.addPlaceholder("votes", "" + entry.getValue())) {
@Override
public void onClick(ClickEvent clickEvent) {
VotingPluginUser user = (VotingPluginUser) getData("User");
new VoteGUI(plugin, player, user)
.open(GUIMethod.valueOf(plugin.getGui().getGuiMethodGUI().toUpperCase()));
}
}.addData("player", entry.getKey().getPlayerName()).addData("User", entry.getKey()));
pos++;
}
if (plugin.getGui().getChestVoteTopBackButton()) {
inv.getPageButtons().add(plugin.getCommandLoader().getBackButton(user).setSlot(1));
}
inv.setPages(true);
inv.setMaxInvSize(plugin.getGui().getChestVoteTopSize());
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.CHEST);
}
}
@@ -0,0 +1,99 @@
package com.bencodez.votingplugin.commands.gui.player;
import java.util.ArrayList;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.UpdatingBInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.messages.StringParser;
import com.bencodez.advancedcore.api.misc.ArrayUtils;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.topvoter.TopVoter;
import com.bencodez.votingplugin.user.VotingPluginUser;
public class VoteTotal extends GUIHandler {
@SuppressWarnings("unused")
private VotingPluginMain plugin;
private VotingPluginUser user;
public VoteTotal(VotingPluginMain plugin, CommandSender player, VotingPluginUser user) {
super(player);
this.plugin = plugin;
this.user = user;
}
@Override
public ArrayList<String> getChat(CommandSender arg0) {
ArrayList<String> msg = new ArrayList<String>();
int daily = user.getTotal(TopVoter.Daily);
int weekly = user.getTotal(TopVoter.Weekly);
int month = user.getTotal(TopVoter.Monthly);
int all = user.getTotal(TopVoter.AllTime);
for (String s : plugin.getConfigFile().getFormatCommandsVoteTotal()) {
String str = StringParser.getInstance().replaceIgnoreCase(s, "%DailyTotal%", "" + daily);
str = StringParser.getInstance().replaceIgnoreCase(str, "%WeeklyTotal%", "" + weekly);
str = StringParser.getInstance().replaceIgnoreCase(str, "%MonthlyTotal%", "" + month);
str = StringParser.getInstance().replaceIgnoreCase(str, "%AllTimeTotal%", "" + all);
str = StringParser.getInstance().replaceIgnoreCase(str, "%player%", user.getPlayerName());
msg.add(str);
}
return ArrayUtils.getInstance().colorize(msg);
}
@Override
public void onBook(Player player) {
// future release?
}
@Override
public void onChat(CommandSender sender) {
sendMessage(getChat(sender));
}
@Override
public void onChest(Player player) {
BInventory inv = new BInventory(plugin.getGui().getChestVoteTotalName());
inv.addPlaceholder("player", user.getPlayerName());
for (final TopVoter top : TopVoter.values()) {
inv.addButton(new UpdatingBInventoryButton(
new ItemBuilder(plugin.getGui().getChestVoteTotalItem(top))
.addPlaceholder("Total", "" + user.getTotal(top)).addPlaceholder("topvoter", top.getName()),
1000, 1000) {
@Override
public void onClick(ClickEvent clickEvent) {
}
@Override
public ItemBuilder onUpdate(Player arg0) {
return new ItemBuilder(plugin.getGui().getChestVoteTotalItem(top))
.addPlaceholder("Total", "" + user.getTotal(top)).addPlaceholder("topvoter", top.getName())
.addPlaceholder("player", user.getPlayerName());
}
});
}
if (plugin.getGui().getChestVoteTotalBackButton()) {
inv.addButton(plugin.getCommandLoader().getBackButton(user));
}
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.valueOf(plugin.getGui().getGuiMethodTotal().toUpperCase()));
}
}
@@ -0,0 +1,244 @@
package com.bencodez.votingplugin.commands.gui.player;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.bookgui.BookWrapper;
import com.bencodez.advancedcore.api.bookgui.Layout;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.UpdatingBInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.messages.MessageBuilder;
import com.bencodez.advancedcore.api.messages.StringParser;
import com.bencodez.advancedcore.api.misc.ArrayUtils;
import com.bencodez.advancedcore.api.rewards.RewardBuilder;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.objects.VoteSite;
import com.bencodez.votingplugin.topvoter.TopVoter;
import com.bencodez.votingplugin.user.UserManager;
import com.bencodez.votingplugin.user.VotingPluginUser;
import xyz.upperlevel.spigot.book.BookUtil;
public class VoteURL extends GUIHandler {
private boolean json;
private VotingPluginMain plugin;
private VotingPluginUser user;
public VoteURL(VotingPluginMain plugin, CommandSender player, VotingPluginUser user, boolean json) {
super(player);
this.plugin = plugin;
this.user = user;
this.json = json;
if (user == null && player instanceof Player) {
this.user = UserManager.getInstance().getVotingPluginUser((Player) player);
}
if (player != null && user != null && player.getName().equals(user.getPlayerName())) {
if (plugin.getConfigFile().isUsePrimaryAccountForPlaceholders() && user.hasPrimaryAccount()) {
user = UserManager.getInstance().getVotingPluginUser(user.getPrimaryAccount());
}
}
}
@Override
public ArrayList<String> getChat(CommandSender arg0) {
ArrayList<String> sites = new ArrayList<String>();
List<String> title = plugin.getConfigFile().getFormatCommandsVoteText();
if (title != null) {
sites.addAll(title);
}
if (plugin.getConfigFile().getFormatCommandsVoteAutoInputSites()) {
int counter = 0;
for (VoteSite voteSite : plugin.getVoteSites()) {
if (!voteSite.isHidden()) {
counter++;
String voteURL = voteSite.getVoteURL(json);
MessageBuilder message = new MessageBuilder(plugin.getConfigFile().getFormatCommandsVoteURLS());
message.replacePlaceholder("num", Integer.toString(counter)).replacePlaceholder("url", voteURL)
.replacePlaceholder("SiteName", voteSite.getDisplayName());
if (user != null && user.getPlayerName() != null) {
message.replacePlaceholder("player", "" + user.getPlayerName()).replacePlaceholder("Next",
"" + user.voteCommandNextInfo(voteSite));
}
sites.add(message.colorize().getText());
}
}
}
if (user != null) {
HashMap<String, String> phs = new HashMap<String, String>();
phs.put("DailyTotal", "" + user.getTotal(TopVoter.Daily));
phs.put("WeekTotal", "" + user.getTotal(TopVoter.Weekly));
phs.put("MonthTotal", "" + user.getTotal(TopVoter.Monthly));
phs.put("Total", "" + user.getTotal(TopVoter.AllTime));
sites = ArrayUtils.getInstance().replacePlaceHolder(sites, phs);
}
return ArrayUtils.getInstance().colorize(sites);
}
private ItemBuilder getItemAll() {
ItemBuilder builderAll = new ItemBuilder(plugin.getGui().getChestVoteURLAlreadyVotedAllUrlsButtonItemSection());
if (plugin.getGui().isChestVoteURLAllUrlsButtonrequireAllSitesVoted()) {
if (user.canVoteAny()) {
builderAll = new ItemBuilder(plugin.getGui().getChestVoteURLCanVoteAllUrlsButtonItemSection());
}
} else {
if (user.canVoteAll()) {
builderAll = new ItemBuilder(plugin.getGui().getChestVoteURLCanVoteAllUrlsButtonItemSection());
}
}
if (!builderAll.hasCustomDisplayName()) {
builderAll.setName("&4All Voting Sites");
}
if (!builderAll.hasCustomLore()) {
builderAll.setLore("&cClick Me");
}
int slot = plugin.getGui().getChestVoteURLAllUrlsButtonSlot();
if (slot >= 0) {
builderAll.setSlot(slot);
}
return builderAll;
}
private ItemBuilder getItemVoteSite(VoteSite voteSite) {
ItemBuilder builder = new ItemBuilder(plugin.getGui().getChestVoteURLAlreadyVotedItemSection());
if (user.canVoteSite(voteSite)) {
builder = new ItemBuilder(plugin.getGui().getChestVoteURLCanVoteItemSection());
builder.setName(plugin.getGui().getChestVoteURLGUISiteNameCanVote().replace("%Name%", voteSite.getDisplayName()));
} else {
builder.setName(plugin.getGui().getChestVoteURLGUISiteName().replace("%Name%", voteSite.getDisplayName()));
builder.addLoreLine(
plugin.getGui().getChestVoteURLNextVote().replace("%Info%", user.voteCommandNextInfo(voteSite)));
}
return builder;
}
@Override
public void onBook(Player player) {
BookWrapper book = new BookWrapper(plugin.getGui().getBookVoteURLBookGUITitle());
for (VoteSite site : plugin.getVoteSites()) {
Layout layout = new Layout(plugin.getGui().getBookVoteURLBookGUILayout()).addPlaceholder("sitename",
site.getDisplayName());
String text = plugin.getGui().getBookVoteURLBookGUIAlreadyVotedText();
ChatColor color = ChatColor.valueOf(plugin.getGui().getBookVoteURLBookGUIAlreadyVotedColor());
if (user.canVoteSite(site)) {
color = ChatColor.valueOf(plugin.getGui().getBookVoteURLBookGUICanVoteColor());
text = plugin.getGui().getBookVoteURLBookGUICanVoteText();
}
String url = StringParser.getInstance().replacePlaceHolder(site.getVoteURLJsonStrip(), "player",
user.getPlayerName());
layout.replaceTextComponent("[UrlText]", BookUtil.TextBuilder.of(text).color(color)
.onClick(BookUtil.ClickAction.openUrl(url)).onHover(BookUtil.HoverAction.showText(url)).build());
book.addLayout(layout);
}
book.open(player);
}
@Override
public void onChat(CommandSender sender) {
sendMessage(getChat(sender));
}
@Override
public void onChest(Player player) {
// normal GUI
BInventory inv = new BInventory(plugin.getGui().getChestVoteURLName());
if (plugin.getGui().getChestVoteURLViewAllUrlsButtonEnabled()) {
ItemBuilder builderAll = getItemAll();
inv.addButton(new UpdatingBInventoryButton(builderAll, 1000, 1000) {
@Override
public void onClick(ClickEvent event) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(event.getPlayer());
json = true;
user.sendMessage(getChat(player));
}
@Override
public ItemBuilder onUpdate(Player player) {
return getItemAll();
}
});
}
int startSlot = plugin.getGui().getChestVoteURLAllUrlsButtonStartSlot();
for (final VoteSite voteSite : plugin.getVoteSites()) {
if (!voteSite.isHidden()) {
ItemBuilder builder = getItemVoteSite(voteSite);
if (startSlot >= 0) {
builder.setSlot(startSlot);
startSlot++;
}
inv.addButton(new UpdatingBInventoryButton(builder, 1000, 1000) {
@Override
public void onClick(ClickEvent event) {
Player player = event.getPlayer();
if (player != null) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(player);
user.sendMessage(StringParser.getInstance().replacePlaceHolder(StringParser.getInstance()
.replacePlaceHolder(StringParser.getInstance().replacePlaceHolder(
plugin.getGui().getChestVoteURLURLText(), "voteurl", voteSite.getVoteURL()),
"sitename", voteSite.getDisplayName()),
"player", player.getName()));
}
}
@Override
public ItemBuilder onUpdate(Player player) {
return getItemVoteSite(voteSite);
}
});
}
}
for (final String str : plugin.getGui().getChestVoteURLExtraItems()) {
inv.addButton(new BInventoryButton(new ItemBuilder(plugin.getGui().getChestVoteURLExtraItemsItem(str))) {
@Override
public void onClick(ClickEvent clickEvent) {
new RewardBuilder(plugin.getGui().getData(), "CHEST.VoteURL.ExtraItems." + str + ".Rewards")
.setGiveOffline(false).send(clickEvent.getPlayer());
;
}
});
}
if (plugin.getGui().getChestVoteURLBackButton()) {
inv.addButton(plugin.getCommandLoader().getBackButton(user));
}
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.valueOf(plugin.getGui().getGuiMethodURL().toUpperCase()));
}
}
@@ -0,0 +1,109 @@
package com.bencodez.votingplugin.commands.gui.player;
import java.util.ArrayList;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.inventory.UpdatingBInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.objects.VoteSite;
import com.bencodez.votingplugin.user.VotingPluginUser;
public class VoteURLVoteSite extends GUIHandler {
private VotingPluginMain plugin;
private VotingPluginUser user;
private String voteSite;
public VoteURLVoteSite(VotingPluginMain plugin, CommandSender player, VotingPluginUser user, String voteSite) {
super(player);
this.plugin = plugin;
this.user = user;
this.voteSite = voteSite;
}
@Override
public ArrayList<String> getChat(CommandSender arg0) {
// TODO Auto-generated method stub
return null;
}
@Override
public void onBook(Player player) {
}
@Override
public void onChat(CommandSender sender) {
}
@Override
public void onChest(Player player) {
if (!plugin.isVoteSite(voteSite)) {
player.sendMessage("Not a valid votesite");
return;
}
VoteSite site = plugin.getVoteSite(voteSite);
BInventory inv = new BInventory(plugin.getGui().getChestVoteURLSiteName());
inv.addPlaceholder("site", site.getDisplayName());
inv.setMeta(player, "VoteSite", site);
if (!plugin.getConfigFile().isAlwaysCloseInventory()) {
inv.dontClose();
}
inv.addButton(
new BInventoryButton(new ItemBuilder(Material.BOW).setName("&4URL").addLoreLine("Click to see URL")) {
@Override
public void onClick(ClickEvent clickEvent) {
VoteSite site = (VoteSite) clickEvent.getMeta("VoteSite");
clickEvent.getWhoClicked().sendMessage(site.getVoteURL());
}
});
inv.addButton(new UpdatingBInventoryButton(
new ItemBuilder(Material.COMPASS).setName("&4Next Vote").addLoreLine(user.voteCommandNextInfo(site)),
1000, 1000) {
@Override
public void onClick(ClickEvent clickEvent) {
new VoteURL(plugin, clickEvent.getPlayer(), user, true).open();
}
@Override
public ItemBuilder onUpdate(Player arg0) {
return new ItemBuilder(Material.COMPASS).setName("&4Next Vote")
.addLoreLine(user.voteCommandNextInfo(site));
}
});
inv.addButton(new BInventoryButton(
new ItemBuilder(Material.CLOCK).setName("&4Last Vote").addLoreLine(user.voteCommandLastLine(site))) {
@Override
public void onClick(ClickEvent clickEvent) {
new VoteURL(plugin, clickEvent.getPlayer(), user, true).open();
}
});
if (plugin.getGui().getChestVoteURLBackButton()) {
inv.addButton(plugin.getCommandLoader().getBackButton(user));
}
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.CHEST);
}
}
@@ -1,53 +1,53 @@
package com.Ben12345rocks.VotingPlugin.Commands.TabCompleter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.command.TabCompleter;
import com.Ben12345rocks.AdvancedCore.Objects.TabCompleteHandler;
import com.Ben12345rocks.AdvancedCore.Util.Misc.StringUtils;
import com.Ben12345rocks.VotingPlugin.Main;
/**
* The Class AdminVoteTabCompleter.
*/
public class AdminVoteTabCompleter implements TabCompleter {
/** The plugin. */
Main plugin = Main.plugin;
/*
* (non-Javadoc)
*
* @see org.bukkit.command.TabCompleter#onTabComplete(org.bukkit.command.
* CommandSender, org.bukkit.command.Command, java.lang.String,
* java.lang.String[])
*/
@Override
public List<String> onTabComplete(CommandSender sender, Command cmd, String alias, String[] args) {
List<String> tab = new ArrayList<String>();
Set<String> cmds = new HashSet<String>();
cmds.addAll(TabCompleteHandler.getInstance().getTabCompleteOptions(plugin.adminVoteCommand, sender, args,
args.length - 1));
for (String str : cmds) {
if (StringUtils.getInstance().startsWithIgnoreCase(str, args[args.length - 1])) {
tab.add(str);
}
}
Collections.sort(tab, String.CASE_INSENSITIVE_ORDER);
return tab;
}
}
package com.bencodez.votingplugin.commands.tabcompleter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.command.TabCompleter;
import com.bencodez.advancedcore.api.command.TabCompleteHandler;
import com.bencodez.advancedcore.api.messages.StringParser;
import com.bencodez.votingplugin.VotingPluginMain;
/**
* The Class AdminVoteTabCompleter.
*/
public class AdminVoteTabCompleter implements TabCompleter {
/** The plugin. */
VotingPluginMain plugin = VotingPluginMain.plugin;
/*
* (non-Javadoc)
*
* @see org.bukkit.command.TabCompleter#onTabComplete(org.bukkit.command.
* CommandSender, org.bukkit.command.Command, java.lang.String,
* java.lang.String[])
*/
@Override
public List<String> onTabComplete(CommandSender sender, Command cmd, String alias, String[] args) {
List<String> tab = new ArrayList<String>();
Set<String> cmds = new HashSet<String>();
cmds.addAll(TabCompleteHandler.getInstance().getTabCompleteOptions(plugin.getAdminVoteCommand(), sender, args,
args.length - 1));
for (String str : cmds) {
if (StringParser.getInstance().startsWithIgnoreCase(str, args[args.length - 1])) {
tab.add(str);
}
}
Collections.sort(tab, String.CASE_INSENSITIVE_ORDER);
return tab;
}
}
@@ -1,107 +1,107 @@
package com.Ben12345rocks.VotingPlugin.Commands.TabCompleter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.command.TabCompleter;
import com.Ben12345rocks.AdvancedCore.Objects.CommandHandler;
import com.Ben12345rocks.AdvancedCore.Objects.TabCompleteHandler;
import com.Ben12345rocks.AdvancedCore.Util.Misc.ArrayUtils;
import com.Ben12345rocks.AdvancedCore.Util.Misc.StringUtils;
import com.Ben12345rocks.VotingPlugin.Main;
/**
* The Class AliasesTabCompleter.
*/
public class AliasesTabCompleter implements TabCompleter {
/** The plugin. */
Main plugin = Main.plugin;
/** The cmd handle. */
public CommandHandler cmdHandle;
private boolean adminCommand;
/*
* (non-Javadoc)
*
* @see org.bukkit.command.TabCompleter#onTabComplete(org.bukkit.command.
* CommandSender, org.bukkit.command.Command, java.lang.String,
* java.lang.String[])
*/
@Override
public List<String> onTabComplete(CommandSender sender, Command cmd, String alias, String[] argsIn) {
ArrayList<String> msgArray = new ArrayList<String>();
msgArray.add("");
for (String arg : argsIn) {
msgArray.add(arg);
}
String[] args = ArrayUtils.getInstance().convert(msgArray);
ArrayList<String> tab = new ArrayList<String>();
Set<String> cmds = new HashSet<String>();
ArrayList<CommandHandler> cmdHandlers = new ArrayList<CommandHandler>();
if (adminCommand) {
cmdHandlers.addAll(plugin.adminVoteCommand);
} else {
cmdHandlers.addAll(plugin.voteCommand);
}
ConcurrentHashMap<String, ArrayList<String>> tabCompletes = TabCompleteHandler.getInstance()
.getTabCompleteOptions();
for (CommandHandler cmdHandle : cmdHandlers) {
if (cmdHandle.getArgs().length >= argsIn.length) {
for (String arg : cmdHandle.getArgs()[0].split("&")) {
if (cmd.getName().equalsIgnoreCase("vote" + arg)
|| cmd.getName().equalsIgnoreCase("adminvote" + arg)) {
// plugin.debug("Found cmd... attempting to get tab
// complete");
args[0] = arg;
boolean argsMatch = true;
for (int i = 0; i < argsIn.length; i++) {
if (args.length >= i) {
if (!cmdHandle.argsMatch(args[i], i)) {
argsMatch = false;
}
}
}
if (argsMatch) {
cmds.addAll(cmdHandle.getTabCompleteOptions(sender, args, argsIn.length, tabCompletes));
}
}
}
}
}
for (String str : cmds) {
if (StringUtils.getInstance().startsWithIgnoreCase(str, args[args.length - 1])) {
tab.add(str);
}
}
Collections.sort(tab, String.CASE_INSENSITIVE_ORDER);
return tab;
}
public AliasesTabCompleter setCMDHandle(CommandHandler cmd, boolean adminCommand) {
cmdHandle = cmd;
this.adminCommand = adminCommand;
return this;
}
}
package com.bencodez.votingplugin.commands.tabcompleter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.command.TabCompleter;
import com.bencodez.advancedcore.api.command.CommandHandler;
import com.bencodez.advancedcore.api.command.TabCompleteHandler;
import com.bencodez.advancedcore.api.messages.StringParser;
import com.bencodez.advancedcore.api.misc.ArrayUtils;
import com.bencodez.votingplugin.VotingPluginMain;
/**
* The Class AliasesTabCompleter.
*/
public class AliasesTabCompleter implements TabCompleter {
private boolean adminCommand;
/** The cmd handle. */
public CommandHandler cmdHandle;
/** The plugin. */
VotingPluginMain plugin = VotingPluginMain.plugin;
/*
* (non-Javadoc)
*
* @see org.bukkit.command.TabCompleter#onTabComplete(org.bukkit.command.
* CommandSender, org.bukkit.command.Command, java.lang.String,
* java.lang.String[])
*/
@Override
public List<String> onTabComplete(CommandSender sender, Command cmd, String alias, String[] argsIn) {
ArrayList<String> msgArray = new ArrayList<String>();
msgArray.add("");
for (String arg : argsIn) {
msgArray.add(arg);
}
String[] args = ArrayUtils.getInstance().convert(msgArray);
ArrayList<String> tab = new ArrayList<String>();
Set<String> cmds = new HashSet<String>();
ArrayList<CommandHandler> cmdHandlers = new ArrayList<CommandHandler>();
if (adminCommand) {
cmdHandlers.addAll(plugin.getAdminVoteCommand());
} else {
cmdHandlers.addAll(plugin.getVoteCommand());
}
ConcurrentHashMap<String, ArrayList<String>> tabCompletes = TabCompleteHandler.getInstance()
.getTabCompleteOptions();
for (CommandHandler cmdHandle : cmdHandlers) {
if (cmdHandle.getArgs().length >= argsIn.length) {
for (String arg : cmdHandle.getArgs()[0].split("&")) {
if (cmd.getName().equalsIgnoreCase("vote" + arg)
|| cmd.getName().equalsIgnoreCase("adminvote" + arg)) {
// plugin.debug("Found cmd... attempting to get tab
// complete");
args[0] = arg;
boolean argsMatch = true;
for (int i = 0; i < argsIn.length; i++) {
if (args.length >= i) {
if (!cmdHandle.argsMatch(args[i], i)) {
argsMatch = false;
}
}
}
if (argsMatch) {
cmds.addAll(cmdHandle.getTabCompleteOptions(sender, args, argsIn.length, tabCompletes));
}
}
}
}
}
for (String str : cmds) {
if (StringParser.getInstance().startsWithIgnoreCase(str, args[args.length - 1])) {
tab.add(str);
}
}
Collections.sort(tab, String.CASE_INSENSITIVE_ORDER);
return tab;
}
public AliasesTabCompleter setCMDHandle(CommandHandler cmd, boolean adminCommand) {
cmdHandle = cmd;
this.adminCommand = adminCommand;
return this;
}
}
@@ -1,54 +1,54 @@
package com.Ben12345rocks.VotingPlugin.Commands.TabCompleter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.command.TabCompleter;
import com.Ben12345rocks.AdvancedCore.Objects.TabCompleteHandler;
import com.Ben12345rocks.AdvancedCore.Util.Misc.StringUtils;
import com.Ben12345rocks.VotingPlugin.Main;
// TODO: Auto-generated Javadoc
/**
* The Class VoteTabCompleter.
*/
public class VoteTabCompleter implements TabCompleter {
/** The plugin. */
Main plugin = Main.plugin;
/*
* (non-Javadoc)
*
* @see org.bukkit.command.TabCompleter#onTabComplete(org.bukkit.command.
* CommandSender, org.bukkit.command.Command, java.lang.String,
* java.lang.String[])
*/
@Override
public List<String> onTabComplete(CommandSender sender, Command cmd, String alias, String[] args) {
ArrayList<String> tab = new ArrayList<String>();
Set<String> cmds = new HashSet<String>();
cmds.addAll(TabCompleteHandler.getInstance().getTabCompleteOptions(plugin.voteCommand, sender, args,
args.length - 1));
for (String str : cmds) {
if (StringUtils.getInstance().startsWithIgnoreCase(str, args[args.length - 1])) {
tab.add(str);
}
}
Collections.sort(tab, String.CASE_INSENSITIVE_ORDER);
return tab;
}
}
package com.bencodez.votingplugin.commands.tabcompleter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.command.TabCompleter;
import com.bencodez.advancedcore.api.command.TabCompleteHandler;
import com.bencodez.advancedcore.api.messages.StringParser;
import com.bencodez.votingplugin.VotingPluginMain;
// TODO: Auto-generated Javadoc
/**
* The Class VoteTabCompleter.
*/
public class VoteTabCompleter implements TabCompleter {
/** The plugin. */
VotingPluginMain plugin = VotingPluginMain.plugin;
/*
* (non-Javadoc)
*
* @see org.bukkit.command.TabCompleter#onTabComplete(org.bukkit.command.
* CommandSender, org.bukkit.command.Command, java.lang.String,
* java.lang.String[])
*/
@Override
public List<String> onTabComplete(CommandSender sender, Command cmd, String alias, String[] args) {
ArrayList<String> tab = new ArrayList<String>();
Set<String> cmds = new HashSet<String>();
cmds.addAll(TabCompleteHandler.getInstance().getTabCompleteOptions(plugin.getVoteCommand(), sender, args,
args.length - 1));
for (String str : cmds) {
if (StringParser.getInstance().startsWithIgnoreCase(str, args[args.length - 1])) {
tab.add(str);
}
}
Collections.sort(tab, String.CASE_INSENSITIVE_ORDER);
return tab;
}
}
@@ -0,0 +1,85 @@
package com.bencodez.votingplugin.config;
import java.io.File;
import com.bencodez.advancedcore.api.yml.YMLFile;
import com.bencodez.advancedcore.api.yml.annotation.AnnotationHandler;
import com.bencodez.advancedcore.api.yml.annotation.ConfigDataBoolean;
import com.bencodez.advancedcore.api.yml.annotation.ConfigDataInt;
import com.bencodez.advancedcore.api.yml.annotation.ConfigDataString;
import com.bencodez.votingplugin.VotingPluginMain;
import lombok.Getter;
public class BungeeSettings extends YMLFile {
@ConfigDataBoolean(path = "BungeeBroadcast")
@Getter
private boolean bungeeBroadcast = false;
@ConfigDataBoolean(path = "BungeeBroadcastAlways")
@Getter
private boolean bungeeBroadcastAlways = false;
@ConfigDataBoolean(path = "BungeeDebug")
@Getter
private boolean bungeeDebug = false;
@ConfigDataBoolean(path = "VotifierBypass")
@Getter
private boolean votifierBypass = false;
@ConfigDataBoolean(path = "TriggerVotifierEvent")
@Getter
private boolean triggerVotifierEvent = false;
@ConfigDataString(path = "BungeeMethod")
@Getter
private String bungeeMethod = "PLUGINMESSAGING";
@ConfigDataString(path = "BungeeServer.Host")
@Getter
private String bungeeServerHost = "";
@ConfigDataInt(path = "BungeeServer.Port")
@Getter
private int bungeeServerPort = 1297;
@ConfigDataBoolean(path = "RemoveInvalidUsers")
@Getter
private boolean removeInvalidUsers = false;
@ConfigDataBoolean(path = "PerServerRewards")
@Getter
private boolean perServerRewards = false;
@ConfigDataString(path = "Server")
@Getter
private String server = "PleaseSet";
@ConfigDataString(path = "SpigotServer.Host")
@Getter
private String spigotServerHost = "";
@ConfigDataInt(path = "SpigotServer.Port")
@Getter
private int spigotServerPort = 1298;
@ConfigDataBoolean(path = "UseBungeecord", secondPath = "UseBungeecoord")
@Getter
private boolean useBungeecoord = false;
public BungeeSettings(VotingPluginMain plugin) {
super(plugin, new File(plugin.getDataFolder(), "BungeeSettings.yml"));
}
@Override
public void loadValues() {
new AnnotationHandler().load(getData(), this);
}
@Override
public void onFileCreation() {
getPlugin().saveResource("BungeeSettings.yml", true);
}
}
Loaded 100 of 134 files, more files were not shown because too many files have changed in this diff. Show more