Compare commits

..
269 Commits
Author SHA1 Message Date
BenCodez ca92a76b15 Undo pom change 2021-08-15 13:28:08 -04:00
BenCodez 637c8a158b Fix javadoc and pom 2021-08-15 13:26:21 -04:00
BenCodez 85b1ed9916 Code cleanup 2021-08-15 13:20:29 -04:00
BenCodez 389c9a138e Update version number to 6.6 2021-08-15 13:10:14 -04:00
BenCodez 7dc5c32db3 Code cleanup 2021-08-15 13:06:57 -04:00
BenCodez dcc1e375a9 Cache extra allsites check value if enabled 2021-08-15 12:33:10 -04:00
BenCodez 176373e2a4 A lot of improvements 2021-08-14 20:09:02 -04:00
BenCodez 2cd7d5db00 Use API to wipe certain data values 2021-08-12 18:36:53 -04:00
BenCodez 05fc747557 Fix a few issues regarding cache system and more 2021-08-11 16:20:55 -04:00
BenCodez 528ca45b26 Speed up voteparty resets 2021-08-11 15:46:13 -04:00
BenCodez b4b420479e Fix caching related to voteparty 2021-08-11 15:29:53 -04:00
BenCodez 10a44f5999 Undo cache setting 2021-08-11 15:19:47 -04:00
BenCodez 03f012eef4 Changes to cache handling 2021-08-08 13:22:17 -04:00
BenCodez e302c29a9e Fix command message 2021-08-07 19:56:45 -04:00
BenCodez 9d7454f9c3 Add command to clear gotten milestones 2021-08-07 18:43:57 -04:00
BenCodez 0731288028 Improve cooldowncheck reward 2021-08-06 21:59:47 -04:00
BenCodez bb061c400f Check permission on remind login, redo cooldown check processing 2021-08-06 19:23:55 -04:00
BenCodez 0ef664efcd Slight modification to caching on vote 2021-08-05 16:18:50 -04:00
BenCodez 0a6c64f9a1 Add more bstats metrics data 2021-08-04 17:02:53 -04:00
BenCodez 3fd328ed91 Fix cache issues with /vote givepoints & add voteshop logging 2021-08-04 16:51:03 -04:00
BenCodez 4923ca6f64 Improve proxy side of things 2021-08-04 16:26:42 -04:00
BenCodez 7e88e4350d Little improvement on background task, default voteparty to online only 2021-08-04 16:14:31 -04:00
BenCodez 04ea20b2c2 Add proxy logging for plugin disable 2021-08-04 14:57:10 -04:00
BenCodez 8491e2e45b Delay updating voteurl a bit 2021-08-04 14:52:55 -04:00
BenCodez 88c1d91675 Some more improvements to background tasks 2021-08-02 19:10:42 -04:00
BenCodez c45c9dc970 Fix a few issues 2021-08-02 13:14:46 -04:00
BenCodez 63807f2617 Add debug message for proxy total setting 2021-08-01 21:47:36 -04:00
BenCodez bfeb112774 Fix issue with vote adding on bungee/velocity 2021-08-01 21:22:27 -04:00
BenCodez d45119ccca Improved handling of top voter 2021-08-01 14:24:30 -04:00
BenCodez 7d5f64636b Improvement to reduce ram usage 2021-07-31 21:46:58 -04:00
BenCodez fbb61808ba Change preload skull handling 2021-07-31 08:37:42 -04:00
BenCodez 800c89f240 update with advancedcore changes 2021-07-30 20:25:58 -04:00
BenCodez 20cc999f0d Change default amount of top voters to load 2021-07-30 16:45:11 -04:00
BenCodez 3604abb307 Add additional debug message 2021-07-29 20:30:28 -04:00
BenCodez 4b56d642e5 Fix top voter 2021-07-29 20:22:54 -04:00
BenCodez 81f0d46aea Internal improvements 2021-07-29 20:13:37 -04:00
BenCodez a2f7336b53 Add time it took for time resets 2021-07-29 15:07:18 -04:00
Ben 38ae2c32dc Update README.md 2021-07-28 15:59:15 -04:00
BenCodez d6b2d21e7c Undo test change 2021-07-28 15:48:15 -04:00
BenCodez 83bcae4a59 Update url 2021-07-28 15:46:22 -04:00
BenCodez b9c862580b Test change to upload snapshots 2021-07-28 15:42:48 -04:00
BenCodez c30f725ed2 Fix handling in top voter caching 2021-07-27 16:22:49 -04:00
BenCodez ca8eb546a5 Fix NPE 2021-07-27 14:51:23 -04:00
BenCodez 0335608162 Adjust caching 2021-07-26 15:50:41 -04:00
BenCodez 593899a434 Fix a few issues with bungee pluginmessaging 2021-07-25 20:21:18 -04:00
BenCodez 8eb8d746d9 Slight improvement on placeholders 2021-07-25 19:47:01 -04:00
BenCodez b8ef63c9ba Little fix 2021-07-25 16:44:03 -04:00
BenCodez dfb8610489 Small improvements 2021-07-25 14:27:47 -04:00
BenCodez 3801059cf6 Use new caching system 2021-07-25 13:41:15 -04:00
BenCodez 2b3aea7f83 Handle empty service sites on votes 2021-07-20 16:57:39 -04:00
Ben af42aa4b50 Update README.md 2021-07-20 16:27:43 -04:00
Ben 2d2b35522e Update README.md 2021-07-20 16:26:31 -04:00
Ben 2a586324d4 Update README.md 2021-07-20 16:25:48 -04:00
BenCodez 5bd9c926ba Update repo url 2021-07-20 16:16:17 -04:00
BenCodez e76c30fca2 Add check for empty service site 2021-07-20 14:49:11 -04:00
BenCodez e42bd3725a Change to votifier event 2021-07-19 18:33:13 -04:00
BenCodez 660c8d9501 Trigger votifier event async 2021-07-19 17:38:38 -04:00
BenCodez 44a65bc347 Update version number 6.5.2 2021-07-18 18:39:16 -04:00
BenCodez f3d27f4816 Add version to bstats for velocity 2021-07-18 17:39:23 -04:00
BenCodez 4c3891fa0a Shorten mysql errors a little bit 2021-07-18 14:54:20 -04:00
BenCodez 5072265549 Update version number to 6.5.1 2021-07-18 14:06:32 -04:00
BenCodez 788b58f9cd Fix issues with wrong votesite being returned on bungee votes 2021-07-18 14:02:38 -04:00
BenCodez 0db34f815f Add internal jar version on velocity 2021-07-18 13:16:56 -04:00
BenCodez 900237b7ea Add maven profile 2021-07-17 20:06:58 -04:00
BenCodez 7fa7c2baf9 Update version to 6.5 2021-07-17 20:02:13 -04:00
BenCodez eec8d706ee Add ignore to insert queries on mysql 2021-07-16 19:04:12 -04:00
BenCodez d292ae4a18 Bug fix 2021-07-16 16:06:24 -04:00
BenCodez f7d04f87db Bug fix 2021-07-14 16:09:15 -04:00
BenCodez 59e2f3da99 Rewrite convert command 2021-07-13 17:16:54 -04:00
BenCodez 2a5b6c23da Check for valid player on /vote givepoints 2021-07-12 19:35:02 -04:00
BenCodez 62560be2ab More reminding bug fixes 2021-07-12 16:40:57 -04:00
BenCodez 64993b8b53 More reminding improvements 2021-07-12 16:35:39 -04:00
BenCodez 18c4cd6b6d Don't show hidden votesites in /vote next 2021-07-12 16:30:20 -04:00
BenCodez 35e14f7a76 Factor in hidden votesites 2021-07-12 16:22:24 -04:00
BenCodez 5c6490159b More attempted fixes at vote reminding 2021-07-12 16:09:31 -04:00
BenCodez 29f0c19a74 Fix vote reminding not reminding correctly 2021-07-12 15:46:35 -04:00
BenCodez 664500d61b Adjust vote reminding 2021-07-12 14:49:16 -04:00
BenCodez e208cdf49b Dependency change 2021-07-11 19:51:55 -04:00
BenCodez e295795ec4 Change maven profiles 2021-07-11 19:50:41 -04:00
BenCodez c9d24b5e88 Update importants 2021-07-11 12:47:47 -04:00
BenCodez f09311e6fc Undo change to relocation 2021-07-11 12:20:58 -04:00
BenCodez 02ea389f12 Update importants 2021-07-10 18:04:29 -04:00
BenCodez 14ccfa3730 update dependency 2021-07-10 17:38:50 -04:00
BenCodez 51ffe88557 Change artifactid to lowercase 2021-07-10 17:37:24 -04:00
BenCodez 7daa0545f3 Change default vote reminding, remind on anysite by default 2021-07-08 20:01:33 -04:00
BenCodez ef7b9cb55a Add log message for votes on velocity 2021-07-08 19:46:16 -04:00
BenCodez a410567de0 Bug fix 2021-07-08 18:47:20 -04:00
BenCodez f00aeab649 Bug fix 2021-07-08 17:43:47 -04:00
BenCodez a4494fc2e7 Fixed issue with velocity uuid check 2021-07-08 17:32:52 -04:00
BenCodez 6333760508 Better console message for ignoring vote on proxy server 2021-07-08 17:16:57 -04:00
BenCodez 012547f950 Update to 1.17.1 2021-07-06 19:48:10 -04:00
BenCodez 631d9c9a1c Code cleanup 2021-07-06 16:56:36 -04:00
BenCodez a61e3176a8 Update profile 2021-07-03 20:23:15 -04:00
BenCodez c013835725 renable javadoc 2021-07-03 19:37:39 -04:00
BenCodez ea8ed1e950 disable javadoc for testing 2021-07-03 19:35:19 -04:00
BenCodez 7dcb3a5f62 temp disable javadoc 2021-07-03 19:34:27 -04:00
BenCodez ed70727a76 Update pom 2021-07-03 19:28:09 -04:00
BenCodez 3418d461e4 Improve vote reminding 2021-07-01 21:28:08 -04:00
BenCodez 1e5ec8226a Small little fixes 2021-07-01 16:42:22 -04:00
BenCodez 993fa19f85 Bug fix 2021-06-30 20:09:01 -04:00
BenCodez 7d3d777cb5 Send update plugin message on vote 2021-06-30 19:41:36 -04:00
BenCodez 9829864a96 Actually open shop page when it's suppose to 2021-06-30 18:38:06 -04:00
BenCodez eec87f642f Don't close inventory unless needed for shop GUI confirmation 2021-06-30 18:28:31 -04:00
BenCodez 9cba16814a Don't generate votesite if site exists but is disabled 2021-06-30 17:01:44 -04:00
BenCodez 44ebd17356 Set bungeecoord-api version 2021-06-30 13:34:58 -04:00
BenCodez ba2312ed46 Add line for mysql in default config 2021-06-30 07:54:44 -04:00
BenCodez 2d8f9e1ca1 Update bstats class 2021-06-29 21:50:10 -04:00
BenCodez 7556a203c2 Fix version of maven plugin 2021-06-29 13:11:27 -04:00
BenCodez 67b8fbcc88 Update version number 2021-06-29 13:05:02 -04:00
BenCodez 4c9f7f76b9 Fix comments 2021-06-28 17:20:04 -04:00
BenCodez df388ca0e3 Add commands to set votestreaks 2021-06-25 16:02:53 -04:00
BenCodez 1d8fc309ff Bug fix 2021-06-23 19:35:44 -04:00
BenCodez 42a159ea82 Little comment change 2021-06-21 17:08:05 -04:00
BenCodez a62187e0cb Better handling when mysql isn't working on bungee & velocity 2021-06-20 18:52:14 -04:00
BenCodez 7896b2f08a Added /av vote (player), with GUI 2021-06-20 14:09:03 -04:00
BenCodez 034d031d79 Add failsafe for votesite loading 2021-06-19 22:12:07 -04:00
BenCodez e228fd6fed Remove barely used command 2021-06-16 21:09:33 -04:00
BenCodez baa85d7222 Update version number to 6.4 2021-06-13 13:37:29 -04:00
BenCodez 5fd2d976a2 Change convert players amount & add login pluginmessage for faster votes 2021-06-13 12:52:30 -04:00
BenCodez 03ac8627df Add libraries for 1.17 support 2021-06-12 20:47:37 -04:00
BenCodez 63d6f2829c Minor changes to sign handling 2021-06-11 19:11:20 -04:00
BenCodez 9824a891b6 Update to 1.17 2021-06-11 16:59:02 -04:00
BenCodez a648074757 Fix velocity issue 2021-06-11 16:12:28 -04:00
BenCodez 5e3a3621bc Make sure directly is created for votingplugin 2021-06-09 15:53:12 -04:00
BenCodez 01a645083f Replace - char for server name for column names 2021-06-06 15:50:17 -04:00
BenCodez 8b9aced63c Add FirstVoteToday reward 2021-06-06 12:33:45 -04:00
BenCodez 6eba6aee3b Don't attempt to get placeholders if cache needs to load 2021-06-06 12:25:35 -04:00
BenCodez 0fbbaaee5d Edit comments in SpecialRewards.yml 2021-06-04 19:37:52 -04:00
BenCodez 57e973b371 Add check for milestones adding milestone count 2021-06-04 15:59:06 -04:00
BenCodez c93f8f06f2 Remove unneeded dependency 2021-06-04 15:45:38 -04:00
BenCodez 6a742dbecc Add debug message 2021-06-03 17:27:27 -04:00
BenCodez c3edbf946c Fix velocity files not generating by default & errors when mysql not set 2021-06-02 19:32:46 -04:00
BenCodez 24fcd076b8 Bug fix 2021-06-02 15:47:57 -04:00
BenCodez a6ac022cb3 Relocate bstats 2021-06-01 17:32:28 -04:00
BenCodez 363c57158f Force generate file when needed 2021-06-01 17:19:58 -04:00
BenCodez d22e22480e Little change to maven profile 2021-05-31 19:56:29 -04:00
BenCodez daf1d95c82 Add jar 2021-05-31 19:51:02 -04:00
BenCodez 35d588477d Fix nuvotifier build issue 2021-05-31 19:50:03 -04:00
BenCodez 2ba3ee0323 Fix jitpack errors 2021-05-31 19:38:34 -04:00
BenCodez ed1ccc0623 Fix velocity not working 2021-05-31 19:22:37 -04:00
BenCodez 2332079002 Fix a few issues 2021-05-31 17:11:30 -04:00
BenCodez 3b7f8afe76 Attempt at velocity support 2021-05-30 16:04:41 -04:00
BenCodez 4c33f3d03c Update version number to 6.3.2 2021-05-30 12:29:21 -04:00
BenCodez cfd317f5a8 Add ability to set hover color on /vote help 2021-05-24 10:01:13 -04:00
BenCodez 063b44aa67 Only send bstats info for bungee settings if enabled 2021-05-24 08:54:02 -04:00
BenCodez a42c00ecf5 Change material for 1.12 2021-05-24 08:02:32 -04:00
BenCodez 9e36f0a500 Add more metrics stats 2021-05-23 16:53:28 -04:00
BenCodez f13386ad29 Add more bstats info for bungee 2021-05-23 16:37:03 -04:00
BenCodez 1c3dbcc8d6 Code cleanup 2021-05-22 20:36:44 -04:00
BenCodez 1d4f34ec84 Update version number to 6.3.1 2021-05-22 20:33:55 -04:00
BenCodez 2ef4194a51 Rename config option for voteparty 2021-05-22 20:00:42 -04:00
BenCodez 98f60f1350 Add missing vote party option 2021-05-22 19:43:43 -04:00
BenCodez 02f98c739f Add pointsonvote for bungee 2021-05-22 19:25:04 -04:00
BenCodez 766fa58157 Add command /av vote (with no other args) 2021-05-22 16:39:46 -04:00
BenCodez ebf0c2fb4f Change cumulative to a much cleaner looking option for total to use 2021-05-22 16:38:07 -04:00
BenCodez bc3cfc7986 Add option for placeholders to always cache 2021-05-22 08:25:28 -04:00
BenCodez e516f5ee87 Reduce delay a bit 2021-05-18 15:59:09 -04:00
BenCodez 7abe7c6224 Bug fix 2021-05-17 16:26:15 -04:00
BenCodez e46a9c7476 Bug fix 2021-05-16 12:30:49 -04:00
BenCodez 891f4a9d24 Bug fix 2021-05-15 15:28:20 -04:00
BenCodez df6d771e4d Add a different option for votelast gui 2021-05-15 15:26:34 -04:00
BenCodez 0f861c4ab7 Add placeholder TimeUntilDayReset 2021-05-12 16:37:11 -04:00
BenCodez 510d4d1895 Delay bungee check 2021-05-12 16:15:22 -04:00
BenCodez cd4af0ff5d Add config option for voteparty 2021-05-12 16:12:31 -04:00
BenCodez 77f508682e Add command argument all for votesite /av vote 2021-05-10 16:07:46 -04:00
BenCodez 3a41a94f47 Merge branch 'master' of https://github.com/BenCodez/VotingPlugin 2021-05-09 13:59:26 -04:00
BenCodez cba19065a4 Add ability to edit bungeesettings.yml 2021-05-09 13:58:32 -04:00
BenCodez 19a652a1fa Add ability to edit config 2021-05-09 13:58:19 -04:00
BenCodez c8f8077159 Add ability to set points on a per server level 2021-05-08 20:27:37 -04:00
BenCodez 60db0e87f4 add method 2021-05-07 20:36:35 -04:00
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
98 changed files with 6729 additions and 2957 deletions

No files matched your search

+1
View File
@@ -5,6 +5,7 @@ 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
+14 -2
View File
@@ -8,10 +8,23 @@ https://www.spigotmc.org/resources/votingplugin.15358/
## License
### Creative Commons Arttribution 3.0 Unported
https://github.com/Ben12345rocks/VotingPlugin/blob/master/VotingPlugin/Resources/LICENSE.txt
https://github.com/BenCodez/VotingPlugin/blob/master/VotingPlugin/Resources/LICENSE.txt
### Maven:
<repository>
<id>BenCodez Repo</id>
<url>https://nexus.bencodez.com/repository/maven-public/</url>
</repository>
<dependency>
<groupId>com.bencodez</groupId>
<artifactId>votingplugin</artifactId>
<version>LATEST</version>
<scope>provided</scope>
</dependency>
BACKUP/OLD WAY
<repository>
<id>jitpack.io</id>
<url>https://jitpack.io</url>
@@ -26,6 +39,5 @@ https://github.com/Ben12345rocks/VotingPlugin/blob/master/VotingPlugin/Resources
Versions:
LATEST - latest stable release
BRANCH-SNAPHSOT - unstable builds
@@ -1,4 +1,13 @@
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
@@ -8,15 +17,43 @@ 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.APILeak=warning
org.eclipse.jdt.core.compiler.problem.annotatedTypeArgumentToUnannotated=info
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
@@ -25,6 +62,70 @@ 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=ignore
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.reportPreviewFeatures=ignore
org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning
org.eclipse.jdt.core.compiler.problem.suppressOptionalErrors=disabled
org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled
org.eclipse.jdt.core.compiler.problem.suppressWarningsNotFullyAnalysed=info
org.eclipse.jdt.core.compiler.problem.syntacticNullAnalysisForFields=disabled
org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
org.eclipse.jdt.core.compiler.problem.terminalDeprecation=warning
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.unstableAutoModuleName=warning
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.release=disabled
org.eclipse.jdt.core.compiler.source=1.8
Binary file not shown.
+20 -5
View File
@@ -7,13 +7,9 @@
# Plugin using bungee, requires plugin on bungee server
UseBungeecord: false
# For pluginmessaging method only
# Whether to broadcast on cached votes
BungeeBroadcastAlways: false
# What type of bungee setup
# Requires restart and set on all servers
# https://github.com/Ben12345rocks/VotingPlugin/wiki/Bungeecoord-Setups
# https://github.com/BenCodez/VotingPlugin/wiki/Bungeecoord-Setups
# Available:
# SOCKETS
# PLUGINMESSAGING
@@ -26,8 +22,27 @@ 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, points will be given on a per server level
# Points will be added when server gets vote from bungee
PerServerPoints: 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
+69 -41
View File
@@ -1,7 +1,7 @@
# VotingPlugin by Ben12345rocks
# VotingPlugin by BenCodez
# Main Config
# See wiki for help:
# https://github.com/Ben12345rocks/VotingPlugin/wiki
# https://github.com/BenCodez/VotingPlugin/wiki
# Config is sorted in sections
# Use Control + F to search with Notepad++
#
@@ -27,9 +27,17 @@ MySQL:
# Affecting this value may affect performance
MaxSize: -1
# Table name prefix, for use with mutliple servers
# Don't use with PLUGINMESSAGING bungee setup
Prefix: ''
#UseSSL: true
#PublicKeyRetrieval: false
#Additional info on connection string
#Line: ''
# --------------------
# 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)
@@ -45,35 +53,34 @@ AllowUnJoinedCheckServer: true
# Configuration for VoteReminding
# By default this should be all setup to work
# as long as vote delays are done properly
# as long as vote delays are done properly in votesites.yml
VoteReminding:
# Enable vote reminding
# This will remind player when he can vote on all sites
# 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"
# To remind if any votesite is available (rather than all) use the permission "VotingPlugin.Login.RemindVotes.Any"
Enabled: true
# Will remind player on login if he can vote
RemindOnLogin: true
# Whether or not to remind only once when the player can vote
# Does not apply to login reminds.
RemindOnlyOnce: true
# Will remind player on login if he can vote
# Ignores value above
RemindOnLogin: true
# Delay to remind votes in minutes
# Only works if above is false
# Set to -1 to disable
RemindDelay: 30
# Run reward files on remind
# By default, the reward file will be created for you
# Run rewards
# and have the default message
# Edit the message at AdvancedCore/Rewards/Remind.yml (or any other reward listed)
# Can add titles and more in the reward file
# Can add titles and more in the reward
# This can also be edited via /av gui
Rewards:
Messages:
Player: '&aRemember to vote!'
Player: '&aYou have %sitesavailable% to vote on still!'
Title:
Enabled: false
Title: '&cRemember to vote!'
@@ -108,6 +115,13 @@ 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
@@ -195,6 +209,9 @@ Format:
Title: '&6&lVoting Player Help'
# Format for help message in /v help
Line: '&6%Command% - &6%HelpMessage%'
# Hover color for help message
# Hex format: #HEXCOLOR
HoverColor: AQUA
# Require permission to see command in /v help or /av help
RequirePermission: true
@@ -217,6 +234,9 @@ Format:
- '&3Highest Month Streak: &3&l%BestMonthlyStreak%'
Today:
Title:
- "&cToday's Votes %page%/%maxpage%"
- '&cPlayerName : VoteSite : Time'
Line: '&6%player% : %VoteSite% : %Time%'
# PlaceHolders:
@@ -241,6 +261,9 @@ 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'
@@ -329,12 +352,12 @@ LoadTopVoter:
# Maxium number of players to show on top voter
# Set to -1 for no limit
MaxiumNumberOfTopVotersToLoad: -1
MaxiumNumberOfTopVotersToLoad: 1000
# 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
@@ -343,6 +366,19 @@ StoreTopVoters:
# 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
@@ -364,6 +400,9 @@ AddTotals: true
# 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:
@@ -394,6 +433,11 @@ PreventRepeatMilestones: false
# Mainly to be used for alts and such
UsePrimaryAccountForPlaceholders: false
# Always force placeholders to return value if the value isn't cached
# This should prevent server from crashing when pulling placeholders on main thread
# Only affects placeholderapi placeholders
AlwaysWaitForCachePlaceholders: false
# If true, permissions will be handled differently
MultiplePermissionsCheck: false
@@ -510,12 +554,14 @@ LoadCommandAliases: true
# Requires AuthMe
WaitUntilLoggedIn: true
# Preload skulls to improve performance
# Preload skulls to improve performance for vote top
# when using skulls as the item to display players
# If false, skulls will be cached as they are used
# assuming loadskulls is enabled
PreloadSkulls: false
# Setting to false disables saving skulls in a cache to improve speeds
# Will reduce ram usage if disabled
# Will reduce ram usage (very little) if disabled, but slow GUI speeds when using skulls
LoadSkulls: true
# Use vault for permission checks
@@ -528,39 +574,21 @@ UseVaultPermissions: false
# - PERMISSION
DisabledCommands: []
# Enable Geyser prefix support
GeyserPrefixSupport: false
GeyserPrefix: '*'
# Enable to true for extra player checks
# Recommend leaving this to false
ExtraBackgroundUpdate: false
# This will prevent spam clicking GUI's to prevent exploits
# Number is time in between clicking in milliseconds
SpamClickTime: 350
SpamClickTime: 150
# Message to send when inventory forced closed when spam clicking
# Uncomment to use
#SpamClickMessage: '&cDetected spam clicking GUI, closing to prevent exploits'
# ---------------------------------------------------------
# Mysql cache options
# Clearing cache forces the plugin to pull from database
# Not needed unless you are using multiple servers
# ---------------------------------------------------------
# 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
# ###############################################################
# Deprecated options, don't recommend using any of these
+46 -12
View File
@@ -12,6 +12,7 @@ GUIMethod:
Last: CHEST #BOOK not available (future update?)
Next: CHEST
Total: CHEST #BOOK not available (future update?)
# GUI for /vote
URL: CHEST
Best: CHEST #BOOK not available (future update?)
Streak: CHEST #BOOK not available (future update?)
@@ -24,12 +25,13 @@ LastMonthGUI: false
CHEST:
# GUI for /vote gui, /vgui, /votegui
VoteGUI:
# Items will be orders as it is below
# 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'
Data: 0
Amount: 1
Name: '&4URL'
Lore:
@@ -40,41 +42,45 @@ CHEST:
Next:
Item:
Material: 'COMPASS'
Data: 0
Amount: 1
Name: '&4Next'
Last:
Item:
Material: 'CLOCK'
Data: 0
Amount: 1
Name: '&4Last'
Total:
Item:
Material: 'CHEST'
Data: 0
Amount: 1
Name: '&4Total'
Top:
Item:
Material: 'OAK_SIGN'
Data: 0
Amount: 1
Name: '&4Top'
Today:
Item:
Material: 'BOOK'
Data: 0
Amount: 1
Name: '&4Today'
Shop:
Item:
Material: 'DIAMOND'
Data: 0
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:
@@ -82,10 +88,15 @@ CHEST:
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'
@@ -109,11 +120,24 @@ CHEST:
Material: 'EMERALD_BLOCK'
Data: 0
Amount: 1
# URL when clicking item in /vote (GUI version)
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
# Lines for each vote site
# %time% = time, using timeformat below
# %timesince% = time since vote
Line: '&6%timeSince%'
VoteNext:
Name: 'VoteNext: %player%'
BackButton: true
@@ -129,19 +153,22 @@ CHEST:
Amount: 1
VoteTop:
Name: 'VoteTop %topvoter%'
BackButton: false
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 page +9
# 9 Slots on the botton are used for page buttons
# 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
@@ -245,6 +272,10 @@ CHEST:
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
@@ -258,11 +289,11 @@ CHEST:
# 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'
Data: 0
Amount: 1
Name: '&4Buy A Diamond'
# You can set skulls of the player using the following
@@ -291,6 +322,9 @@ CHEST:
#NotBuyable: false
# Rewards to run if player buys successfully
Rewards:
# Run command on purchase
#Commands:
#- 'command here'
Items:
Diamond:
Material: 'DIAMOND'
+23 -11
View File
@@ -1,13 +1,16 @@
# To disable reward set value to []
# 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
# FirstVote: {} (All in one line)
# Rewards will be given if there is a reward to give, otherwise they will be ignored
# First vote rewards
FirstVote:
Messages:
Player: '&aYou voted for your first time!'
# First vote of the day reward
FirstVoteToday: {}
# All vote rewards
# Reward for voting on all sites in one day
@@ -28,9 +31,12 @@ Cumulative:
# 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
# Valid options
# AllTime
# Monthly
# Weekly
# Daily
TotalToUse: AllTime
Rewards:
Messages:
Player: '&aYou got %cumulative% cumulative votes!'
@@ -47,6 +53,9 @@ VoteParty:
# recieve the reward
# If false, only players who voted get rewards
GiveAllPlayers: false
# If true, give online players the vote party reward
# Can also use RewardType: ONLINE if you wanted
GiveOnlinePlayersOnly: true
# If true, the vote count will reset each day
ResetEachDay: false
# If true, the vote count will reset each week
@@ -70,7 +79,7 @@ VoteParty:
Commands: []
# Rewards to give per player
Rewards:
# Uncomment below for online player rewards only
# Uncomment below for online players to be rewarded only
#RewardType: ONLINE
Commands:
- say %player%
@@ -136,7 +145,10 @@ VoteStreak:
Week: 50
Month: 50
# Reward given when vote cooldown ended
# Reward given when all votesites are available to vote on
# Don't use this unless you really need it
# Little performance intensive
# Recommend add RewardType: ONLINE for it to only work online
VoteCoolDownEndedReward: []
# ONLY USE THIS FOR TITLES/SOUNDS AND OTHER EFFECTS
@@ -145,14 +157,14 @@ VoteCoolDownEndedReward: []
# 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: []
AnySiteRewards: {}
# Rewards to run when player logs in
LoginRewards: []
LoginRewards: {}
# Rewards to run when player logs off
# Will queue until player logs in unless forceoffline is enabled
LogoutRewards: []
LogoutRewards: {}
EnableMonthlyAwards: true
+7 -1
View File
@@ -15,6 +15,9 @@ 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)
@@ -44,6 +47,9 @@ VoteSites:
# 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 while the player is offline
# This basiclly disables offline voting if set to true, don't misinterpret this option
@@ -114,4 +120,4 @@ VoteSites:
# Reward for any site
# Similar to AnySiteReward
# This requires the site to be configured in order to get the reward.
EverySiteReward: []
EverySiteReward: {}
+23 -3
View File
@@ -38,18 +38,38 @@ BlockedServers:
# MYSQL
BungeeMethod: PLUGINMESSAGING
FallBackServer: factions
# 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
PointsOnVote: 1
# 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
# ----------------------------
# SOCKET METHOD Settings
# 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:
+16 -3
View File
@@ -5,7 +5,10 @@ description: Highly Customizable Voting Listener!
website: https://www.spigotmc.org/resources/votingplugin.15358/
author: BenCodez
softdepend: [MVdWPlaceholders, Votifier, VotifierPlus, NuVotifier, CMI, Vault, PlaceholderAPI, ProtocolLib, MVdWPlaceholderAPI, AuthMe]
loadbefore: [MCPerks]
api-version: 1.13
libraries:
- org.openjdk.nashorn:nashorn-core:15.2
commands:
vote:
description: Vote command
@@ -218,7 +221,15 @@ commands:
adminvoteRunCMD:
description: Command Alias
aliases: avRunCMD
adminvoteuseruuidremove:
description: Command Alias
aliases: avuseruuidremove
adminvoteedit:
description: Command Alias
aliases: avedit
adminvoteResetMilestoneCount:
description: Command Alias
aliases: avResetMilestoneCount
permissions:
VotingPlugin.Player:
description: Allows basic access player commands
@@ -242,7 +253,9 @@ permissions:
description: Permission to create sign
VotingPlugin.Admin.GenerateServiceSite:
description: Permission for generating votesite message
VotingPlugin.Login.RemindVotes.Any:
description: Remind if player can vote on any website, rather than all
VotingPlugin.Login.RemindVotes:
description: Permission to allow timed reminders
VotingPlugin.Login.RemindVotes.All:
description: Remind if player can vote on all votesites, rather than any
default: false
@@ -1,2 +1,3 @@
time: '${timestamp}'
profile: ${build.profile.id}
profile: ${build.profile.id}
version: ${project.version}
+170 -101
View File
@@ -3,8 +3,8 @@
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.bencodez</groupId>
<artifactId>VotingPlugin</artifactId>
<version>6.1.2</version>
<artifactId>votingplugin</artifactId>
<version>6.6</version>
<packaging>jar</packaging>
<name>VotingPlugin</name>
<properties>
@@ -13,13 +13,6 @@
<github.global.server>github</github.global.server>
<project.build.sourceEncoding>Cp1252</project.build.sourceEncoding>
</properties>
<distributionManagement>
<repository>
<id>internal.repo</id>
<name>Temporary Staging Repository</name>
<url>file://${project.build.directory}/mvn-repo</url>
</repository>
</distributionManagement>
<build>
<resources>
<resource>
@@ -79,7 +72,7 @@
<plugin>
<groupId>org.projectlombok</groupId>
<artifactId>lombok-maven-plugin</artifactId>
<version>1.18.12.0</version>
<version>1.18.20.0</version>
<executions>
<execution>
<id>delombok</id>
@@ -101,15 +94,20 @@
<version>2.4.3</version>
<configuration>
<shadedArtifactAttached>false</shadedArtifactAttached>
<minimizeJar>true</minimizeJar>
<filters>
<filter>
<artifact>mysql-connector-java</artifact>
<includes>
<include>**</include>
</includes>
</filter>
</filters>
<relocations>
<!-- Lets relocate the shaded API so we dont cause any conflicts with
other plugins -->
<relocation>
<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}.votingplugin</shadedPattern>
@@ -127,8 +125,12 @@
<shadedPattern>${project.groupId}.votingplugin.hikari</shadedPattern>
</relocation>
<relocation>
<pattern>xyz.upperlevel.spigot.book</pattern>
<shadedPattern>${project.groupId}.votingplugin.upperlevel.book</shadedPattern>
<pattern>org.bstats</pattern>
<shadedPattern>${project.groupId}.votingplugin.bstats</shadedPattern>
</relocation>
<relocation>
<pattern>xyz.upperlevel.spigot</pattern>
<shadedPattern>${project.groupId}.votingplugin.advancedcore.xyz.upperlevel.spigot</shadedPattern>
</relocation>
</relocations>
</configuration>
@@ -147,50 +149,16 @@
</excludes>
</artifactSet>
<createDependencyReducedPom>false</createDependencyReducedPom>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-javadoc-plugin</artifactId>
<version>2.10.4</version>
<executions>
<execution>
<id>attach-javadocs</id>
<goals>
<goal>jar</goal>
</goals>
<phase>deploy</phase>
<configuration>
<sourcepath>${project.basedir}/target/delombok</sourcepath>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<groupId>com.github.github</groupId>
<artifactId>site-maven-plugin</artifactId>
<version>0.12</version>
<executions>
<execution>
<id>javadoc</id>
<goals>
<goal>site</goal>
</goals>
<phase>deploy</phase>
<configuration>
<message>Maven javadoc for ${project.version}</message>
<noJekyll>true</noJekyll>
<outputDirectory>${project.build.directory}/apidocs
</outputDirectory>
<branch>refs/heads/gh-pages</branch>
<includes>
<include>**/*</include>
</includes>
<repositoryName>VotingPlugin</repositoryName>
<repositoryOwner>BenCodez</repositoryOwner>
<server>github</server>
<filters>
<filter>
<artifact>*:*</artifact>
<excludes>
<exclude>META-INF/*.SF</exclude>
<exclude>META-INF/*.DSA</exclude>
<exclude>META-INF/*.RSA</exclude>
</excludes>
</filter>
</filters>
</configuration>
</execution>
</executions>
@@ -227,14 +195,7 @@
<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>
</repository>
<repository>
<id>maven-central</id>
<url>https://oss.sonatype.org/content/groups/public</url>
@@ -244,28 +205,21 @@
<url>https://oss.sonatype.org/content/repositories/snapshots</url>
</repository>
<repository>
<id>bintray-repo</id>
<url>https://dl.bintray.com/nuvotifier/maven/</url>
<id>velocity</id>
<url>https://nexus.velocitypowered.com/repository/maven-public/</url>
</repository>
<repository>
<id>bencodez repo</id>
<url>https://nexus.bencodez.com/repository/maven-public/</url>
</repository>
</repositories>
<dependencies>
<!--<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.16.4-R0.1-SNAPSHOT</version>
<version>1.17.1-R0.1-SNAPSHOT</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>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
@@ -275,25 +229,15 @@
<dependency>
<groupId>net.md-5</groupId>
<artifactId>bungeecord-api</artifactId>
<version>LATEST</version>
<version>1.17-R0.1-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.vexsoftware</groupId>
<artifactId>nuvotifier-universal</artifactId>
<version>2.3.4</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.tchristofferson</groupId>
<artifactId>ConfigUpdater</artifactId>
<version>1.1-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.5.6</version>
<scope>test</scope>
<version>2.7.2</version>
<scope>system</scope>
<systemPath>${project.basedir}/Jars/nuvotifier.jar</systemPath>
</dependency>
<dependency>
<groupId>be.maximvdw</groupId>
@@ -302,21 +246,40 @@
<scope>system</scope>
<systemPath>${project.basedir}/Jars/MVdWPlaceholderAPI.jar</systemPath>
</dependency>
<dependency>
<groupId>com.velocitypowered</groupId>
<artifactId>velocity-api</artifactId>
<version>1.1.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.bstats</groupId>
<artifactId>bstats-velocity</artifactId>
<version>2.2.1</version>
<scope>compile</scope>
</dependency>
</dependencies>
<profiles>
<profile>
<id>prod</id>
<activation>
<activeByDefault>true</activeByDefault>
</activation>
<properties>
<build.profile.id>prod</build.profile.id>
</properties>
<activation>
<activeByDefault>true</activeByDefault>
</activation>
<repositories>
<repository>
<id>jitpack.io</id>
<url>https://jitpack.io</url>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>com.github.bencodez</groupId>
<artifactId>advancedcore</artifactId>
<version>master-SNAPSHOT</version>
<scope>compile</scope>
</dependency>
</dependencies>
</profile>
@@ -325,10 +288,17 @@
<properties>
<build.profile.id>prod2</build.profile.id>
</properties>
<distributionManagement>
<repository>
<id>internal.repo</id>
<name>Temporary Staging Repository</name>
<url>file://${project.build.directory}/mvn-repo</url>
</repository>
</distributionManagement>
<dependencies>
<dependency>
<groupId>com.bencodez</groupId>
<artifactId>AdvancedCore</artifactId>
<artifactId>advancedcore</artifactId>
<version>LATEST</version>
<scope>compile</scope>
</dependency>
@@ -342,11 +312,110 @@
<dependencies>
<dependency>
<groupId>com.bencodez</groupId>
<artifactId>AdvancedCore</artifactId>
<artifactId>advancedcore</artifactId>
<version>LATEST</version>
<scope>compile</scope>
</dependency>
</dependencies>
</profile>
<profile>
<id>deploy</id>
<properties>
<build.profile.id>deploy</build.profile.id>
</properties>
<dependencies>
<dependency>
<groupId>com.bencodez</groupId>
<artifactId>advancedcore</artifactId>
<version>LATEST</version>
<scope>compile</scope>
</dependency>
</dependencies>
<distributionManagement>
<snapshotRepository>
<id>nexus</id>
<url>https://nexus.bencodez.com/repository/maven-snapshots/</url>
</snapshotRepository>
<repository>
<id>nexus</id>
<url>https://nexus.bencodez.com/repository/maven-releases/</url>
</repository>
</distributionManagement>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-javadoc-plugin</artifactId>
<version>2.10.4</version>
<executions>
<execution>
<id>attach-javadocs</id>
<goals>
<goal>jar</goal>
</goals>
<phase>deploy</phase>
<configuration>
<sourcepath>${project.basedir}/target/delombok</sourcepath>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-deploy-plugin</artifactId>
<version>3.0.0-M1</version>
<configuration>
<skip>true</skip>
</configuration>
</plugin>
<plugin>
<groupId>org.sonatype.plugins</groupId>
<artifactId>nexus-staging-maven-plugin</artifactId>
<version>1.5.1</version>
<executions>
<execution>
<id>default-deploy</id>
<phase>deploy</phase>
<goals>
<goal>deploy</goal>
</goals>
</execution>
</executions>
<configuration>
<serverId>nexus</serverId>
<nexusUrl>https://nexus.bencodez.com/nexus/</nexusUrl>
<skipStaging>true</skipStaging>
</configuration>
</plugin>
<plugin>
<groupId>com.github.github</groupId>
<artifactId>site-maven-plugin</artifactId>
<version>0.12</version>
<executions>
<execution>
<id>javadoc</id>
<goals>
<goal>site</goal>
</goals>
<phase>deploy</phase>
<configuration>
<message>Maven javadoc for ${project.version}</message>
<noJekyll>true</noJekyll>
<outputDirectory>${project.build.directory}/apidocs
</outputDirectory>
<branch>refs/heads/gh-pages</branch>
<includes>
<include>**/*</include>
</includes>
<repositoryName>VotingPlugin</repositoryName>
<repositoryOwner>BenCodez</repositoryOwner>
<server>github</server>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
</profiles>
</project>
@@ -8,23 +8,24 @@ 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 int getPoints() {
return user.getPoints();
}
public boolean removePoints(int points) {
return user.removePoints(points);
}
}
public void setPoints(int points) {
user.setPoints(points);
}
}
@@ -11,6 +11,7 @@ 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;
@@ -52,38 +53,55 @@ public class BungeeHandler {
} else if (method.equals(BungeeMethod.PLUGINMESSAGING)) {
plugin.registerBungeeChannels("vp:vp");
plugin.getPluginMessaging().setDebug(true);
plugin.getPluginMessaging().add(new PluginMessageHandler("Vote") {
@Override
public void onRecieve(String subChannel, ArrayList<String> args) {
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 + " on " + service);
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(UUID.fromString(uuid),
player);
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;
}
boolean wasOnline = Boolean.valueOf(args.get(4));
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);
BungeeMessageData text = new BungeeMessageData(args.get(6));
boolean wasOnline = Boolean.valueOf(args.get(4));
user.clearCache();
BungeeMessageData text = new BungeeMessageData(args.get(6));
user.bungeeVotePluginMessaging(service, time, text);
boolean setTotals = Boolean.valueOf(args.get(7));
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);
user.clearCache();
user.bungeeVotePluginMessaging(service, time, text, !setTotals, wasOnline);
if (plugin.getBungeeSettings().isPerServerPoints()) {
user.addPoints(plugin.getConfigFile().getPointsOnVote());
}
if (!plugin.getBungeeSettings().isBungeeBroadcast()) {
if (wasOnline || plugin.getBungeeSettings().isBungeeBroadcastAlways()) {
VoteSite site = plugin.getVoteSite(service, true);
if (site != null) {
site.broadcastVote(user, false);
} else {
plugin.getLogger().warning("No votesite for " + service);
}
}
}
}
if (args.size() > 4 && Boolean.valueOf(args.get(5))) {
plugin.getServerData().addServiceSite(service);
if (Boolean.valueOf(args.get(5))) {
plugin.getServerData().addServiceSite(service);
}
} else {
plugin.getLogger().warning("Incompatible version with bungee, please update all servers");
}
}
@@ -92,31 +110,49 @@ public class BungeeHandler {
plugin.getPluginMessaging().add(new PluginMessageHandler("VoteOnline") {
@Override
public void onRecieve(String subChannel, ArrayList<String> args) {
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 + " on " + service);
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(UUID.fromString(uuid),
player);
user.clearCache();
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();
user.bungeeVotePluginMessaging(service, time, text);
if (plugin.getBungeeSettings().isPerServerPoints()) {
user.addPoints(plugin.getConfigFile().getPointsOnVote());
}
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);
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, true);
if (site != null) {
site.broadcastVote(user, false);
} else {
plugin.getLogger().warning("No votesite for " + service);
}
}
}
}
if (args.size() > 4 && Boolean.valueOf(args.get(5))) {
plugin.getServerData().addServiceSite(service);
if (Boolean.valueOf(args.get(5))) {
plugin.getServerData().addServiceSite(service);
}
} else {
plugin.getLogger().warning("Incompatible version with bungee, please update all servers");
}
}
});
@@ -141,7 +177,7 @@ public class BungeeHandler {
String uuid = args.get(0);
String service = args.get(1);
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(UUID.fromString(uuid));
VoteSite site = plugin.getVoteSite(service);
VoteSite site = plugin.getVoteSite(service, true);
if (site != null) {
site.broadcastVote(user, false);
} else {
@@ -149,7 +185,7 @@ public class BungeeHandler {
}
}
});
plugin.getPluginMessaging().add(new PluginMessageHandler("Status") {
@Override
public void onRecieve(String subChannel, ArrayList<String> args) {
@@ -174,7 +210,7 @@ public class BungeeHandler {
@Override
public void onReceive(String[] data) {
if (data.length > 3) {
if (data.length > 5) {
plugin.extraDebug("BungeeVote from " + data[2] + ", processing");
String uuid = data[1];
VotingPluginUser user = null;
@@ -186,7 +222,11 @@ public class BungeeHandler {
user.clearCache();
user.bungeeVote(data[3]);
if (plugin.getBungeeSettings().isPerServerPoints()) {
user.addPoints(plugin.getConfigFile().getPointsOnVote());
}
user.bungeeVote(data[3], new BungeeMessageData(data[4]), !Boolean.valueOf(data[5]));
}
}
});
@@ -195,7 +235,7 @@ public class BungeeHandler {
@Override
public void onReceive(String[] data) {
if (data.length > 3) {
if (data.length > 5) {
plugin.extraDebug("BungeeVoteOnline from " + data[2] + ", processing");
String uuid = data[1];
VotingPluginUser user = null;
@@ -207,7 +247,11 @@ public class BungeeHandler {
user.clearCache();
user.bungeeVoteOnline(data[3]);
if (plugin.getBungeeSettings().isPerServerPoints()) {
user.addPoints(plugin.getConfigFile().getPointsOnVote());
}
user.bungeeVoteOnline(data[3], new BungeeMessageData(data[4]), !Boolean.valueOf(data[5]));
}
}
});
@@ -217,7 +261,7 @@ public class BungeeHandler {
@Override
public void onReceive(String[] data) {
if (data.length > 2) {
VoteSite site = plugin.getVoteSite(data[1]);
VoteSite site = plugin.getVoteSite(data[1], true);
String p = data[3];
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(p);
if (site != null) {
@@ -1,9 +1,12 @@
package com.bencodez.votingplugin;
import org.bukkit.entity.Player;
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;
import com.bencodez.votingplugin.user.VotingPluginUser;
public class VotingPluginHooks {
private static VotingPluginHooks instance = new VotingPluginHooks();
@@ -20,6 +23,12 @@ public class VotingPluginHooks {
RewardHandler.getInstance().addInjectedReward(inject);
}
public void backgroundUpdate(Player player) {
VotingPluginUser user = getUserManager().getVotingPluginUser(player);
user.offVote();
user.checkOfflineRewards();
}
public VotingPluginMain getMainClass() {
return VotingPluginMain.plugin;
}
File diff suppressed because it is too large. Load diff
@@ -1,5 +1,7 @@
package com.bencodez.votingplugin;
import java.util.concurrent.Callable;
import com.bencodez.advancedcore.api.metrics.BStatsMetrics;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import com.bencodez.votingplugin.user.UserManager;
@@ -7,12 +9,12 @@ import com.bencodez.votingplugin.user.UserManager;
public class VotingPluginMetrics {
public void load(VotingPluginMain plugin) {
BStatsMetrics metrics = new BStatsMetrics(plugin);
BStatsMetrics metrics = new BStatsMetrics(plugin, 38);
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_firstvote") {
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_firstvote", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
if (RewardHandler.getInstance().hasRewards(plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getFirstVoteRewardsPath())) {
return "True";
@@ -20,11 +22,11 @@ public class VotingPluginMetrics {
return "False";
}
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_everysite") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_everysite", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
if (RewardHandler.getInstance().hasRewards(plugin.getConfigVoteSites().getData(),
plugin.getConfigVoteSites().getEverySiteRewardPath())) {
return "True";
@@ -32,11 +34,11 @@ public class VotingPluginMetrics {
return "False";
}
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_allsites") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_allsites", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
if (RewardHandler.getInstance().hasRewards(plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getAllSitesRewardPath())) {
return "True";
@@ -44,11 +46,11 @@ public class VotingPluginMetrics {
return "False";
}
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_cumulative") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_cumulative", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
if (plugin.getSpecialRewardsConfig().getCumulativeVotes().size() == 0) {
return "False";
} else {
@@ -60,22 +62,22 @@ public class VotingPluginMetrics {
return "False";
}
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_voteparty") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_voteparty", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
if (!plugin.getSpecialRewardsConfig().getVotePartyEnabled()) {
return "False";
} else {
return "True";
}
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_milestone") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_milestone", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
if (plugin.getSpecialRewardsConfig().getMilestoneVotes().size() == 0) {
return "False";
} else {
@@ -87,11 +89,11 @@ public class VotingPluginMetrics {
return "False";
}
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_anysitereward") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_anysitereward", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
if (RewardHandler.getInstance().hasRewards(plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getAnySiteRewardsPath())) {
return "True";
@@ -99,11 +101,11 @@ public class VotingPluginMetrics {
return "False";
}
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_votestreakday") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_votestreakday", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
for (String s : plugin.getSpecialRewardsConfig().getVoteStreakVotes("Day")) {
if (plugin.getSpecialRewardsConfig().getVoteStreakRewardEnabled("Day", s)
@@ -115,12 +117,12 @@ public class VotingPluginMetrics {
}
return "False";
}
});
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_votestreakweek") {
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_votestreakweek", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
for (String s : plugin.getSpecialRewardsConfig().getVoteStreakVotes("Week")) {
if (plugin.getSpecialRewardsConfig().getVoteStreakRewardEnabled("Week", s)
@@ -132,12 +134,12 @@ public class VotingPluginMetrics {
return "False";
}
});
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_votestreakmonth") {
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_votestreakmonth", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
for (String s : plugin.getSpecialRewardsConfig().getVoteStreakVotes("Month")) {
if (plugin.getSpecialRewardsConfig().getVoteStreakRewardEnabled("Month", s)
@@ -149,33 +151,33 @@ public class VotingPluginMetrics {
return "False";
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("numberofsites") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("numberofsites", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
return "" + plugin.getVoteSites().size();
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("numberofrewards") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("numberofrewards", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
return "" + RewardHandler.getInstance().getRewards().size();
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("autocreatevotesites") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("autocreatevotesites", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
return "" + plugin.getConfigFile().isAutoCreateVoteSites();
}
});
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("numberofusers") {
metrics.addCustomChart(new BStatsMetrics.SimplePie("numberofusers", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
int total = UserManager.getInstance().getAllUUIDs().size();
if (total < 1000) {
return "<1000";
@@ -185,59 +187,138 @@ public class VotingPluginMetrics {
return "1000-10000";
}
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("data_storage") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("number_of_users", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
int total = UserManager.getInstance().getAllUUIDs().size() / 1000;
return "" + total;
}
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("data_storage", new Callable<String>() {
@Override
public String call() throws Exception {
return plugin.getOptions().getStorageType().toString();
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("DisableCheckOnWorldChange") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("DisableCheckOnWorldChange", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
return "" + plugin.getOptions().isDisableCheckOnWorldChange();
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("votereminding_enabled") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("votereminding_enabled", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
return "" + plugin.getConfigFile().getVoteRemindingEnabled();
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("LoadTopVoter_Monthly") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("LoadTopVoter_Monthly", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
return "" + plugin.getConfigFile().getLoadTopVoterMonthly();
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("LoadTopVoter_Weekly") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("LoadTopVoter_Weekly", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
return "" + plugin.getConfigFile().getLoadTopVoterWeekly();
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("LoadTopVoter_Daily") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("LoadTopVoter_Daily", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
return "" + plugin.getConfigFile().getLoadTopVoterDaily();
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("bungeemethod") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("bungeemethod", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
if (plugin.getBungeeSettings().isUseBungeecoord()) {
return "" + plugin.getBungeeHandler().getMethod().toString();
} else {
return "Disabled";
}
}
});
}));
if (plugin.getBungeeSettings().isUseBungeecoord()) {
metrics.addCustomChart(new BStatsMetrics.SimplePie("bungeebroadcast", new Callable<String>() {
@Override
public String call() throws Exception {
return "" + plugin.getBungeeSettings().isBungeeBroadcast();
}
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("bungeebroadcastalways", new Callable<String>() {
@Override
public String call() throws Exception {
return "" + plugin.getBungeeSettings().isBungeeBroadcastAlways();
}
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("perserverrewards", new Callable<String>() {
@Override
public String call() throws Exception {
return "" + plugin.getBungeeSettings().isPerServerRewards();
}
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("perserverpoints", new Callable<String>() {
@Override
public String call() throws Exception {
return "" + plugin.getBungeeSettings().isPerServerPoints();
}
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("triggervotifierevent", new Callable<String>() {
@Override
public String call() throws Exception {
return "" + plugin.getBungeeSettings().isTriggerVotifierEvent();
}
}));
}
metrics.addCustomChart(new BStatsMetrics.SimplePie("geyserprefixsupport", new Callable<String>() {
@Override
public String call() throws Exception {
return "" + plugin.getOptions().isGeyserPrefixSupport();
}
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("using_dev_build", new Callable<String>() {
@Override
public String call() throws Exception {
return "" + plugin.getProfile().contains("dev");
}
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("votepointtransfering", new Callable<String>() {
@Override
public String call() throws Exception {
return "" + plugin.getConfigFile().isAllowVotePointTransfers();
}
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("votecooldown_check_enabled", new Callable<String>() {
@Override
public String call() throws Exception {
return "" + (!plugin.getConfigFile().isDisableCoolDownCheck() && RewardHandler.getInstance()
.hasRewards(plugin.getSpecialRewardsConfig().getData(), "VoteCoolDownEndedReward"));
}
}));
}
}
@@ -0,0 +1,68 @@
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 {
private VotingPluginMain plugin;
private Timer timer;
ConcurrentLinkedQueue<String> votedPlayers = new ConcurrentLinkedQueue<String>();
public BroadcastHandler(VotingPluginMain plugin, int delay) {
this.plugin = plugin;
schelude(delay);
}
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);
}
}
public void onVote(String player) {
votedPlayers.add(player);
}
public void schelude(int delay) {
if (timer != null) {
timer.cancel();
timer = new Timer();
} else {
timer = new Timer();
}
timer.schedule(new TimerTask() {
@Override
public void run() {
check();
}
}, 1000 * 60, 1000 * 60 * delay);
}
}
File diff suppressed because it is too large. Load diff
@@ -12,15 +12,25 @@ public class BungeeMessageData {
@Getter
private int allTimeTotal = 0;
@Getter
private int monthTotal = 0;
@Getter
private int weeklyTotal = 0;
@Getter
private int dailyTotal = 0;
@Getter
private int milestoneCount = 0;
@Getter
private int monthTotal = 0;
@Getter
private int points = 0;
@Getter
private int milestoneCount = 0;
private int weeklyTotal = 0;
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;
}
public BungeeMessageData(String str) {
String[] data = str.split(Pattern.quote("//"));
@@ -40,14 +50,4 @@ public class BungeeMessageData {
+ 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;
}
}
@@ -1,472 +0,0 @@
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;
}
}
@@ -21,6 +21,10 @@ public class Config {
this.bungee = bungee;
}
public boolean getAllowUnJoined() {
return getData().getBoolean("AllowUnJoined", false);
}
public List<String> getBlockedServers() {
return getData().getStringList("BlockedServers");
}
@@ -28,15 +32,15 @@ public class Config {
public boolean getBroadcast() {
return getData().getBoolean("Broadcast", false);
}
public boolean getAllowUnJoined() {
return getData().getBoolean("AllowUnJoined",false);
}
public String getBungeeHost() {
return getData().getString("BungeeServer.Host", "");
}
public boolean getBungeeManageTotals() {
return getData().getBoolean("BungeeManageTotals", true);
}
public String getBungeeMethod() {
return getData().getString("BungeeMethod", "SOCKETS");
}
@@ -53,6 +57,10 @@ public class Config {
return getData().getString("FallBackServer", "");
}
public int getPointsOnVote() {
return getData().getInt("PointsOnVote", 1);
}
public boolean getSendVotesToAllServers() {
return getData().getBoolean("SendVotesToAllServers");
}
@@ -65,6 +73,10 @@ public class Config {
return getData().getSection("SpigotServers").getKeys();
}
public boolean getWaitForUserOnline() {
return getData().getBoolean("WaitForUserOnline", false);
}
public void load() {
if (!bungee.getDataFolder().exists()) {
bungee.getDataFolder().mkdir();
@@ -29,18 +29,6 @@ public class NonVotedPlayersCache {
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);
@@ -82,6 +70,18 @@ public class NonVotedPlayersCache {
}
}
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 save() {
try {
ConfigurationProvider.getProvider(YamlConfiguration.class).save(data,
@@ -26,4 +26,9 @@ public class OfflineBungeeVote {
this.text = text;
}
@Override
public String toString() {
return "VoteCache:" + playerName + "/" + uuid + "/" + service + "/" + time + "/" + realVote + "/" + text;
}
}
@@ -26,7 +26,6 @@ public class VoteCache {
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) {
@@ -37,7 +36,6 @@ public class VoteCache {
section.set("Time", voteData.getTime());
section.set("Real", voteData.isRealVote());
section.set("Text", voteData.getText());
save();
}
public void clearData() {
@@ -0,0 +1,34 @@
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) {
plugin.getProxy().getScheduler().runAsync(plugin, new Runnable() {
@Override
public void run() {
Vote vote = event.getVote();
String serviceSite = vote.getServiceName();
plugin.getLogger().info("Vote received " + vote.getUsername() + " from service site " + serviceSite);
if (serviceSite.isEmpty()) {
serviceSite = "Empty";
}
plugin.vote(vote.getUsername(), serviceSite, true);
}
});
}
}
@@ -10,6 +10,7 @@ import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.sql.SQLException;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.ArrayList;
@@ -21,16 +22,17 @@ 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.api.user.usercache.value.DataValue;
import com.bencodez.advancedcore.api.user.usercache.value.DataValueInt;
import com.bencodez.advancedcore.api.user.usercache.value.DataValueString;
import com.bencodez.advancedcore.api.user.userstorage.Column;
import com.bencodez.advancedcore.bungeeapi.mysql.BungeeMySQL;
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 com.vexsoftware.votifier.bungee.events.VotifierEvent;
import com.vexsoftware.votifier.model.Vote;
import lombok.Getter;
import net.md_5.bungee.api.CommandSender;
@@ -40,11 +42,12 @@ 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.Listener;
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 implements net.md_5.bungee.api.plugin.Listener {
public class VotingPluginBungee extends Plugin implements Listener {
private HashMap<String, ArrayList<OfflineBungeeVote>> cachedOnlineVotes = new HashMap<String, ArrayList<OfflineBungeeVote>>();
@@ -63,41 +66,66 @@ public class VotingPluginBungee extends Plugin implements net.md_5.bungee.api.pl
@Getter
private BungeeMySQL mysql;
private NonVotedPlayersCache nonVotedPlayersCache;
private SocketHandler socketHandler;
private VoteCache voteCacheFile;
private NonVotedPlayersCache nonVotedPlayersCache;
private boolean votifierEnabled = true;
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) {
sendPluginMessageServer(server, "Vote", cache.getPlayerName(), cache.getUuid(),
cache.getService(), "" + cache.getTime(), Boolean.FALSE.toString(),
"" + cache.isRealVote(), cache.getText());
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, new ArrayList<OfflineBungeeVote>());
cachedVotes.put(server, newSet);
}
}
}
}
}
public void checkOnlineVotes(ProxiedPlayer player, String uuid) {
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()) {
String server = getProxy().getPlayer(UUID.fromString(uuid)).getServer().getInfo().getName();
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());
"" + cache.isRealVote(), cache.getText(), "" + getConfig().getBungeeManageTotals(),
"" + BungeeVersion.getPluginMessageVersion());
}
cachedOnlineVotes.put(uuid, new ArrayList<OfflineBungeeVote>());
}
@@ -147,9 +175,11 @@ public class VotingPluginBungee extends Plugin implements net.md_5.bungee.api.pl
if (p != null && p.isConnected()) {
return p.getUniqueId().toString();
}
String str = mysql.getUUID(playerName);
if (str != null) {
return str;
if (mysql != null) {
String str = mysql.getUUID(playerName);
if (str != null) {
return str;
}
}
if (nonVotedPlayersCache != null) {
return nonVotedPlayersCache.playerExists(playerName);
@@ -157,66 +187,36 @@ public class VotingPluginBungee extends Plugin implements net.md_5.bungee.api.pl
return "";
}
private int getValue(ArrayList<Column> cols, String column) {
private int getValue(ArrayList<Column> cols, String column, int toAdd) {
for (Column d : cols) {
if (d.getName().equalsIgnoreCase(column)) {
Object value = d.getValue();
DataValue value = d.getValue();
int num = 0;
if (value instanceof Integer) {
if (value.isInt()) {
num = value.getInt();
} else if (value.isString()) {
try {
num = (int) value;
} catch (ClassCastException | NullPointerException ex) {
}
} else if (value instanceof String) {
try {
num = Integer.parseInt((String) value);
num = Integer.parseInt(value.getString());
} catch (Exception e) {
}
}
return num;
return num + toAdd;
}
}
return 0;
return toAdd;
}
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;
}
private void loadMysql() {
mysql = new BungeeMySQL(this, "VotingPlugin_Users", config.getData()) {
@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++;
@Override
public void debug(SQLException e) {
if (config.getDebug()) {
e.printStackTrace();
}
}
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();
}
}
@Override
public void onEnable() {
getProxy().getPluginManager().registerListener(this, this);
config = new Config(this);
config.load();
mysql = new BungeeMySQL("VotingPlugin_Users", config.getData());
};
// column types
getMysql().alterColumnType("TopVoterIgnore", "VARCHAR(5)");
@@ -242,9 +242,75 @@ public class VotingPluginBungee extends Plugin implements net.md_5.bungee.api.pl
getMysql().alterColumnType("HighestWeeklyTotal", "INT DEFAULT '0'");
getMysql().alterColumnType("LastMonthTotal", "INT DEFAULT '0'");
getMysql().alterColumnType("OfflineRewards", "MEDIUMTEXT");
getMysql().alterColumnType("DayVoteStreakLastUpdate", "MEDIUMTEXT");
}
/*
* 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 int; }
*/
@Override
public void onDisable() {
if (method.equals(BungeeMethod.PLUGINMESSAGING)) {
getLogger().info("VotingPlugin saving vote cache: " + cachedVotes.size() + "/" + cachedOnlineVotes.size());
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++;
}
}
voteCacheFile.save();
}
nonVotedPlayersCache.save();
getLogger().info("VotingPlugin disabled");
}
@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));
getProxy().getPluginManager().registerListener(this, this);
} catch (Exception e) {
}
}
config = new Config(this);
config.load();
getProxy().getPluginManager().registerCommand(this, new VotingPluginBungeeCommand(this));
boolean mysqlLoaded = true;
try {
if (!config.getData().getString("Host", "").isEmpty()) {
loadMysql();
} else {
mysqlLoaded = false;
getLogger().severe("MySQL settings not set in bungeeconfig.yml");
}
} catch (Exception e) {
mysqlLoaded = false;
e.printStackTrace();
}
method = BungeeMethod.getByName(config.getBungeeMethod());
if (method == null) {
method = BungeeMethod.PLUGINMESSAGING;
@@ -252,114 +318,116 @@ public class VotingPluginBungee extends Plugin implements net.md_5.bungee.api.pl
this.getProxy().registerChannel("vp:vp");
if (method.equals(BungeeMethod.MYSQL)) {
// this.getProxy().registerChannel("vp:vp");
if (mysqlLoaded) {
if (method.equals(BungeeMethod.MYSQL)) {
// this.getProxy().registerChannel("vp:vp");
} else if (method.equals(BungeeMethod.PLUGINMESSAGING)) {
voteCacheFile = new VoteCache(this);
voteCacheFile.load();
} else if (method.equals(BungeeMethod.PLUGINMESSAGING)) {
voteCacheFile = new VoteCache(this);
voteCacheFile.load();
nonVotedPlayersCache = new NonVotedPlayersCache(this);
nonVotedPlayersCache.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")));
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);
}
cachedVotes.put(server, vote);
} catch (Exception e) {
e.printStackTrace();
}
} 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")));
try {
for (String player : voteCacheFile.getPlayers()) {
ArrayList<OfflineBungeeVote> vote = new ArrayList<OfflineBungeeVote>();
for (String num : voteCacheFile.getOnlineVotes(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);
}
cachedOnlineVotes.put(player, vote);
} catch (Exception e) {
e.printStackTrace();
}
} catch (Exception e) {
e.printStackTrace();
}
voteCacheFile.clearData();
voteCacheFile.clearData();
getProxy().getScheduler().schedule(this, new Runnable() {
getProxy().getScheduler().schedule(this, new Runnable() {
@Override
public void run() {
for (String server : cachedVotes.keySet()) {
checkCachedVotes(server);
@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);
for (String player : cachedOnlineVotes.keySet()) {
checkOnlineVotes(getProxy().getPlayer(UUID.fromString(player)), player);
getProxy().getScheduler().schedule(this, new Runnable() {
@Override
public void run() {
if (nonVotedPlayersCache != null) {
debug("Checking nonvotedplayers.yml...");
nonVotedPlayersCache.check();
}
}
}
}, 15l, TimeUnit.SECONDS);
}, 1l, 60l, TimeUnit.MINUTES);
} else if (method.equals(BungeeMethod.SOCKETS)) {
encryptionHandler = new EncryptionHandler(new File(getDataFolder(), "secretkey.key"));
getProxy().getScheduler().schedule(this, new Runnable() {
socketHandler = new SocketHandler(getDescription().getVersion(), config.getBungeeHost(),
config.getBungeePort(), encryptionHandler, config.getDebug());
@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.add(new SocketReceiver() {
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);
@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() {
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);
@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()));
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()));
}
}
}
}
@@ -372,7 +440,27 @@ public class VotingPluginBungee extends Plugin implements net.md_5.bungee.api.pl
metrics.addCustomChart(new BStatsMetricsBungee.SimplePie("sendtoallservers",
() -> "" + getConfig().getSendVotesToAllServers()));
getLogger().info("VotingPlugin loaded, using method: " + method.toString());
metrics.addCustomChart(
new BStatsMetricsBungee.SimplePie("allowunjoined", () -> "" + getConfig().getAllowUnJoined()));
metrics.addCustomChart(
new BStatsMetricsBungee.SimplePie("pointsonvote", () -> "" + getConfig().getPointsOnVote()));
metrics.addCustomChart(new BStatsMetricsBungee.SimplePie("bungeemanagetotals",
() -> "" + getConfig().getBungeeManageTotals()));
metrics.addCustomChart(
new BStatsMetricsBungee.SimplePie("waitforuseronline", () -> "" + getConfig().getWaitForUserOnline()));
getLogger().info("VotingPlugin loaded, using method: " + method.toString() + ", PluginMessagingVersion: "
+ BungeeVersion.getPluginMessageVersion());
}
@EventHandler
public void onLogin(PostLoginEvent event) {
if (nonVotedPlayersCache != null) {
nonVotedPlayersCache.addPlayer(event.getPlayer());
}
}
@EventHandler
@@ -380,12 +468,14 @@ public class VotingPluginBungee extends Plugin implements net.md_5.bungee.api.pl
if (!ev.getTag().equals("vp:vp".toLowerCase())) {
return;
}
ev.setCancelled(true);
if (!(ev.getSender() instanceof Server))
if (!(ev.getSender() instanceof Server)) {
debug("Ignore plugin message");
return;
}
ByteArrayInputStream instream = new ByteArrayInputStream(ev.getData());
DataInputStream in = new DataInputStream(instream);
try {
@@ -394,12 +484,25 @@ public class VotingPluginBungee extends Plugin implements net.md_5.bungee.api.pl
String subchannel = in.readUTF();
int size = in.readInt();
debug("Received plugin message, processing...");
// 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();
debug("Login: " + player);
ProxiedPlayer p = getProxy().getPlayer(player);
if (p != null && p.isConnected()) {
String server = p.getServer().getInfo().getName();
checkCachedVotes(server);
checkOnlineVotes(p, p.getUniqueId().toString(), server);
}
return;
} else {
// reforward message
out.writeUTF(subchannel);
out.writeInt(size);
@@ -417,13 +520,6 @@ public class VotingPluginBungee extends Plugin implements net.md_5.bungee.api.pl
}
}
@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();
@@ -433,19 +529,10 @@ public class VotingPluginBungee extends Plugin implements net.md_5.bungee.api.pl
@Override
public void run() {
checkCachedVotes(server);
checkOnlineVotes(event.getPlayer(), uuid);
checkOnlineVotes(event.getPlayer(), uuid, server);
}
}, 2, TimeUnit.SECONDS);
}
@EventHandler
public void onVote(VotifierEvent event) {
Vote vote = event.getVote();
getLogger().info("Vote received " + vote.getUsername() + " from service site " + vote.getServiceName());
vote(vote.getUsername(), vote.getServiceName(), true);
}, 3, TimeUnit.SECONDS);
}
private UUID parseUUIDFromString(String uuidAsString) {
@@ -466,8 +553,19 @@ public class VotingPluginBungee extends Plugin implements net.md_5.bungee.api.pl
return new UUID(mostSigBits, leastSigBits);
}
public void reload() {
public void reload(boolean loadMysql) {
config.load();
if (loadMysql) {
try {
if (!config.getData().getString("Host", "").isEmpty()) {
loadMysql();
} else {
getLogger().severe("MySQL settings not set in bungeeconfig.yml");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
public void sendPluginMessageServer(String server, String channel, String... messageData) {
@@ -503,11 +601,12 @@ public class VotingPluginBungee extends Plugin implements net.md_5.bungee.api.pl
}
}
public void sendSocketVote(String name, String service) {
public void sendSocketVote(String name, String service, BungeeMessageData text) {
String uuid = getUUID(name);
if (config.getSendVotesToAllServers()) {
sendServerMessage("bungeevote", uuid, name, service);
sendServerMessage("bungeevote", uuid, name, service, text.toString(),
"" + getConfig().getBungeeManageTotals());
if (config.getBroadcast()) {
sendServerMessage("BungeeBroadcast", service, uuid, name);
}
@@ -525,7 +624,8 @@ public class VotingPluginBungee extends Plugin implements net.md_5.bungee.api.pl
server = config.getFallBack();
}
sendServerMessageServer(server, "bungeevoteonline", uuid, name, service);
sendServerMessageServer(server, "bungeevoteonline", uuid, name, service, text.toString(),
"" + getConfig().getBungeeManageTotals());
if (config.getBroadcast()) {
sendServerMessage("BungeeBroadcast", service, uuid, name);
}
@@ -548,19 +648,20 @@ public class VotingPluginBungee extends Plugin implements net.md_5.bungee.api.pl
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) {
if (player == null || player.isEmpty()) {
getLogger().info("No name from vote on " + service);
return;
}
if (method.equals(BungeeMethod.SOCKETS)) {
sendSocketVote(player, service);
} else if (method.equals(BungeeMethod.PLUGINMESSAGING)) {
public synchronized 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()) {
@@ -578,24 +679,48 @@ public class VotingPluginBungee extends Plugin implements net.md_5.bungee.api.pl
}
uuid = u.toString();
} else {
getLogger().info("Ignoring vote from " + player);
getLogger().info("Ignoring vote from " + player + " since player hasn't joined before");
return;
}
}
player = getProperName(uuid, player);
if (!mysql.getUuids().contains(uuid)) {
mysql.update(uuid, "PlayerName", player, DataType.STRING);
BungeeMessageData text = null;
if (getConfig().getBungeeManageTotals()) {
if (mysql == null) {
getLogger().severe("Mysql is not loaded correctly, stopping vote processing");
return;
}
if (!mysql.getUuids().contains(uuid)) {
mysql.update(uuid, "PlayerName", new DataValueString(player));
}
ArrayList<Column> data = mysql.getExactQuery(new Column("uuid", new DataValueString(uuid)));
int allTimeTotal = getValue(data, "AllTimeTotal", 1);
int monthTotal = getValue(data, "MonthTotal", 1);
int weeklyTotal = getValue(data, "WeeklyTotal", 1);
int dailyTotal = getValue(data, "DailyTotal", 1);
int points = getValue(data, "Points", getConfig().getPointsOnVote());
int milestoneCount = getValue(data, "MilestoneCount", 1);
text = new BungeeMessageData(allTimeTotal, monthTotal, weeklyTotal, dailyTotal, points, milestoneCount);
ArrayList<Column> update = new ArrayList<Column>();
update.add(new Column("AllTimeTotal", new DataValueInt(allTimeTotal)));
update.add(new Column("MonthTotal", new DataValueInt(monthTotal)));
update.add(new Column("WeeklyTotal", new DataValueInt(weeklyTotal)));
update.add(new Column("DailyTotal", new DataValueInt(dailyTotal)));
update.add(new Column("Points", new DataValueInt(points)));
update.add(new Column("MilestoneCount", new DataValueInt(milestoneCount)));
debug("Setting totals " + text.toString());
mysql.update(uuid, update);
} else {
text = new BungeeMessageData(0, 0, 0, 0, 0, 0);
}
ArrayList<Column> data = mysql.getExactQuery(new Column("uuid", uuid, DataType.STRING));
BungeeMessageData 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));
/*
* String text = mysqlUpdate(data, uuid, "AllTimeTotal", 1) + "//" +
* mysqlUpdate(data, uuid, "MonthTotal", 1) + "//" + mysqlUpdate(data, uuid,
@@ -606,49 +731,68 @@ public class VotingPluginBungee extends Plugin implements net.md_5.bungee.api.pl
long time = LocalDateTime.now().atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
if (config.getSendVotesToAllServers()) {
for (String s : getProxy().getServers().keySet()) {
if (!config.getBlockedServers().contains(s)) {
ServerInfo info = getProxy().getServerInfo(s);
if (info.getPlayers().isEmpty()) {
// cache
if (!cachedVotes.containsKey(s)) {
cachedVotes.put(s, new ArrayList<OfflineBungeeVote>());
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");
}
ArrayList<OfflineBungeeVote> list = cachedVotes.get(s);
list.add(new OfflineBungeeVote(player, uuid, service, time, realVote, text.toString()));
cachedVotes.put(s, list);
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);
debug("Caching vote for " + player + " on " + service + " for " + s);
} else {
// send
sendPluginMessageServer(s, "Vote", player, uuid, service, "" + time,
Boolean.TRUE.toString(), "" + realVote, text.toString());
} 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());
} else {
if (!cachedOnlineVotes.containsKey(uuid)) {
cachedOnlineVotes.put(uuid, new ArrayList<OfflineBungeeVote>());
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);
}
ArrayList<OfflineBungeeVote> list = cachedOnlineVotes.get(uuid);
if (list == null) {
list = new ArrayList<OfflineBungeeVote>();
for (String s : getProxy().getServers().keySet()) {
sendPluginMessageServer(s, "VoteUpdate", uuid);
}
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();
}
}
}
@@ -17,8 +17,12 @@ public class VotingPluginBungeeCommand extends Command {
if (sender.hasPermission("votingplugin.admin")) {
if (args.length > 0) {
if (args[0].equalsIgnoreCase("reload")) {
bungee.reload();
sender.sendMessage(new TextComponent("Reloading VotingPluginBungee"));
bungee.reload(false);
sender.sendMessage(new TextComponent("&aReloading VotingPluginBungee"));
}
if (args[0].equalsIgnoreCase("reloadmysql")) {
bungee.reload(true);
sender.sendMessage(new TextComponent("&aReloading VotingPluginBungee with MySQL"));
}
if (args[0].equalsIgnoreCase("vote")) {
if (args.length >= 2) {
@@ -31,26 +35,28 @@ public class VotingPluginBungeeCommand extends Command {
if (args[0].equalsIgnoreCase("status")) {
if (bungee.getMethod().equals(BungeeMethod.SOCKETS)) {
sender.sendMessage(new TextComponent(
"Checking status, waiting for response, check console, method: sockets"));
"&aChecking status, waiting for response, check console, method: sockets"));
bungee.status(sender);
} else if (bungee.getMethod().equals(BungeeMethod.PLUGINMESSAGING)){
} else if (bungee.getMethod().equals(BungeeMethod.PLUGINMESSAGING)) {
sender.sendMessage(new TextComponent(
"Checking status, waiting for response, check console, method: plugin messaging"));
"&aChecking status, waiting for response, check console, method: plugin messaging"));
bungee.status(sender);
} else {
sender.sendMessage(new TextComponent("Not using socket/pluginmessage method, command unavailable"));
sender.sendMessage(
new TextComponent("&aNot using socket/pluginmessage method, command unavailable"));
}
}
if (args[0].equalsIgnoreCase("help")) {
TextComponent[] msg = new TextComponent[3];
TextComponent[] msg = new TextComponent[4];
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");
msg[1] = new TextComponent("&avotingpluginbungee reloadmysql - Reload plugin including mysql");
msg[2] = new TextComponent("&avotingpluginbungee vote (player) (servicesite) - Send bungee vote");
msg[3] = new TextComponent("&avotingpluginbungee status - Check socket connection status");
sender.sendMessage(msg);
}
}
} else {
sender.sendMessage(new TextComponent("You do not have permission to do this!"));
sender.sendMessage(new TextComponent("&cYou do not have permission to do this!"));
}
}
}
@@ -0,0 +1,81 @@
package com.bencodez.votingplugin.bungee.velocity;
import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import com.bencodez.advancedcore.bungeeapi.velocity.VelocityYMLFile;
import ninja.leaping.configurate.ConfigurationNode;
public class Config extends VelocityYMLFile {
public Config(File file) {
super(file);
}
public boolean getAllowUnJoined() {
return getBoolean(getNode("AllowUnJoined"), false);
}
public List<String> getBlockedServers() {
return getStringList(getNode("BlockedServers"), new ArrayList<String>());
}
public boolean getBroadcast() {
return getBoolean(getNode("Broadcast"), false);
}
public String getBungeeHost() {
return getString(getNode("BungeeServer", "Host"), "");
}
public boolean getBungeeManageTotals() {
return getBoolean(getNode("BungeeManageTotals"), true);
}
public String getBungeeMethod() {
return getString(getNode("BungeeMethod"), "PLUGINMESSAGING");
}
public int getBungeePort() {
return getInt(getNode("BungeeServer", "Port"), 1297);
}
public boolean getDebug() {
return getBoolean(getNode("Debug"), false);
}
public String getFallBack() {
return getString(getNode("FallBackServer"), "");
}
public ConfigurationNode getMysqlNode() {
return getNode("MySQL");
}
public int getPointsOnVote() {
return getInt(getNode("PointsOnVote"), 1);
}
public boolean getSendVotesToAllServers() {
return getBoolean(getNode("SendVotesToAllServers"), true);
}
public ConfigurationNode getSpigotServerConfiguration(String s) {
return getNode("SpigotServers", s);
}
public Collection<String> getSpigotServers() {
ArrayList<String> list = new ArrayList<String>();
for (ConfigurationNode conf : getNode("SpigotServers").getChildrenList()) {
list.add(conf.getKey().toString());
}
return list;
}
public boolean getWaitForUserOnline() {
return getBoolean(getNode("WaitForUserOnline"), false);
}
}
@@ -0,0 +1,63 @@
package com.bencodez.votingplugin.bungee.velocity;
import java.io.File;
import com.bencodez.advancedcore.bungeeapi.velocity.VelocityYMLFile;
import com.velocitypowered.api.proxy.Player;
public class NonVotedPlayersCache extends VelocityYMLFile {
private VotingPluginVelocity plugin;
public NonVotedPlayersCache(File file, VotingPluginVelocity plugin) {
super(file);
this.plugin = plugin;
}
public void addPlayer(Player player) {
if (!plugin.getMysql().containsKeyQuery(player.getUniqueId().toString())) {
addPlayer(player.getUniqueId().toString(), player.getUsername());
}
}
private void addPlayer(String uuid, String playerName) {
getNode("NonVotedPlayers", playerName, "UUID").setValue(uuid);
getNode("NonVotedPlayers", playerName, "LastTime").setValue(System.currentTimeMillis());
save();
}
public void check() {
for (String player : getKeys(getNode("NonVotedPlayers"))) {
long time = getNode("NonVotedPlayers", player, "LastTime").getLong(0);
if ((System.currentTimeMillis() - time) > 1000 * 60 * 60 * 24 * 5) {
remove(player);
} else {
String uuid = getNode("NonVotedPlayers", player, "UUID").getString("");
if (!uuid.isEmpty()) {
if (plugin.getMysql().containsKeyQuery(uuid)) {
remove(player);
}
} else {
remove(player);
}
}
}
save();
}
public String playerExists(String playerName) {
if (!getNode("NonVotedPlayers", playerName).isEmpty()) {
return getNode("NonVotedPlayers", playerName, "UUID").getString("");
}
return "";
}
private void remove(String player) {
plugin.debug("Removing nonvotedplayer: " + player);
getNode("NonVotedPlayers", player).setValue(null);
save();
}
}
@@ -0,0 +1,69 @@
package com.bencodez.votingplugin.bungee.velocity;
import java.io.File;
import java.util.Collection;
import com.bencodez.advancedcore.bungeeapi.velocity.VelocityYMLFile;
import com.bencodez.votingplugin.bungee.OfflineBungeeVote;
import ninja.leaping.configurate.ConfigurationNode;
public class VoteCache extends VelocityYMLFile {
public VoteCache(File file) {
super(file);
}
public void addVote(String server, int num, OfflineBungeeVote voteData) {
String[] path = new String[] { "VoteCache", server, "" + num };
getNode(path, "Name").setValue(voteData.getPlayerName());
getNode(path, "Service").setValue(voteData.getService());
getNode(path, "UUID").setValue(voteData.getUuid());
getNode(path, "Time").setValue(voteData.getTime());
getNode(path, "Real").setValue(voteData.isRealVote());
getNode(path, "Text").setValue(voteData.getText());
}
public void addVoteOnline(String player, int num, OfflineBungeeVote voteData) {
String[] path = new String[] { "OnlineCache", player, "" + num };
getNode(path, "Name").setValue(voteData.getPlayerName());
getNode(path, "Service").setValue(voteData.getService());
getNode(path, "UUID").setValue(voteData.getUuid());
getNode(path, "Time").setValue(voteData.getTime());
getNode(path, "Real").setValue(voteData.isRealVote());
getNode(path, "Text").setValue(voteData.getText());
}
public void clearData() {
getNode("VoteCache").setValue(null);
getNode("OnlineCache").setValue(null);
save();
}
public Collection<String> getOnlineVotes(String name) {
return getKeys(getNode("OnlineCache", name));
}
public ConfigurationNode getOnlineVotes(String name, String num) {
return getNode("OnlineCache", name, num);
}
public Collection<String> getPlayers() {
return getKeys(getNode("OnlineCache"));
}
public Collection<String> getServers() {
return getKeys(getNode("VoteCache"));
}
public Collection<String> getServerVotes(String server) {
return getKeys(getNode("OnlineCache", server));
}
public ConfigurationNode getServerVotes(String server, String num) {
return getNode("VoteCache", server, num);
}
}
@@ -0,0 +1,14 @@
package com.bencodez.votingplugin.bungee.velocity;
import com.velocitypowered.api.proxy.messages.ChannelIdentifier;
public class VotingPluginChannelIdentifier implements ChannelIdentifier {
public VotingPluginChannelIdentifier() {
}
@Override
public String getId() {
return "vp:vp";
}
}
@@ -0,0 +1,880 @@
package com.bencodez.votingplugin.bungee.velocity;
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.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.file.Path;
import java.security.CodeSource;
import java.sql.SQLException;
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 java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import org.bstats.charts.SimplePie;
import org.bstats.velocity.Metrics;
import org.slf4j.Logger;
import com.bencodez.advancedcore.api.misc.ArrayUtils;
import com.bencodez.advancedcore.api.misc.encryption.EncryptionHandler;
import com.bencodez.advancedcore.api.user.usercache.value.DataValue;
import com.bencodez.advancedcore.api.user.usercache.value.DataValueInt;
import com.bencodez.advancedcore.api.user.usercache.value.DataValueString;
import com.bencodez.advancedcore.api.user.userstorage.Column;
import com.bencodez.advancedcore.bungeeapi.mysql.VelocityMySQL;
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.bungee.OfflineBungeeVote;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.google.inject.Inject;
import com.velocitypowered.api.command.CommandMeta;
import com.velocitypowered.api.event.Subscribe;
import com.velocitypowered.api.event.connection.PluginMessageEvent;
import com.velocitypowered.api.event.player.ServerConnectedEvent;
import com.velocitypowered.api.event.proxy.ProxyInitializeEvent;
import com.velocitypowered.api.event.proxy.ProxyShutdownEvent;
import com.velocitypowered.api.plugin.Dependency;
import com.velocitypowered.api.plugin.Plugin;
import com.velocitypowered.api.plugin.annotation.DataDirectory;
import com.velocitypowered.api.proxy.Player;
import com.velocitypowered.api.proxy.ProxyServer;
import com.velocitypowered.api.proxy.messages.ChannelIdentifier;
import com.velocitypowered.api.proxy.messages.MinecraftChannelIdentifier;
import com.velocitypowered.api.proxy.server.RegisteredServer;
import com.vexsoftware.votifier.model.Vote;
import com.vexsoftware.votifier.velocity.event.VotifierEvent;
import lombok.Getter;
import ninja.leaping.configurate.ConfigurationNode;
import ninja.leaping.configurate.yaml.YAMLConfigurationLoader;
@Plugin(id = "votingplugin", name = "VotingPlugin", version = "1.0", url = "https://www.spigotmc.org/resources/votingplugin.15358/", description = "VotingPlugin Velocity Version", authors = {
"BenCodez" }, dependencies = { @Dependency(id = "nuvotifier", optional = true) })
public class VotingPluginVelocity {
private static final ChannelIdentifier CHANNEL = MinecraftChannelIdentifier.create("vp", "vp");
private HashMap<String, ArrayList<OfflineBungeeVote>> cachedOnlineVotes = new HashMap<String, ArrayList<OfflineBungeeVote>>();
private HashMap<RegisteredServer, ArrayList<OfflineBungeeVote>> cachedVotes = new HashMap<RegisteredServer, ArrayList<OfflineBungeeVote>>();
private HashMap<String, ClientHandler> clientHandles;
@Getter
private Config config;
private final Path dataDirectory;
private EncryptionHandler encryptionHandler;
@Getter
private final Logger logger;
@Getter
private BungeeMethod method;
private final Metrics.Factory metricsFactory;
@Getter
private VelocityMySQL mysql;
private NonVotedPlayersCache nonVotedPlayersCache;
private final ProxyServer server;
private SocketHandler socketHandler;
private VoteCache voteCacheFile;
@Inject
public VotingPluginVelocity(ProxyServer server, Logger logger, Metrics.Factory metricsFactory,
@DataDirectory Path dataDirectory) {
this.server = server;
this.logger = logger;
this.dataDirectory = dataDirectory;
this.metricsFactory = metricsFactory;
}
public void checkCachedVotes(RegisteredServer serverToCheck) {
if (!serverToCheck.getPlayersConnected().isEmpty()) {
if (cachedVotes.containsKey(serverToCheck)
&& !config.getBlockedServers().contains(serverToCheck.getServerInfo().getName())) {
ArrayList<OfflineBungeeVote> c = cachedVotes.get(serverToCheck);
ArrayList<OfflineBungeeVote> newSet = new ArrayList<OfflineBungeeVote>();
if (!c.isEmpty()) {
for (OfflineBungeeVote cache : c) {
boolean toSend = true;
if (getConfig().getWaitForUserOnline()) {
Player p = null;
if (server.getPlayer(UUID.fromString(cache.getUuid())).isPresent()) {
p = server.getPlayer(UUID.fromString(cache.getUuid())).get();
}
if (p == null || !p.isActive()) {
toSend = false;
} else if (p != null && p.isActive() && !p.getCurrentServer().get().getServerInfo()
.getName().equals(serverToCheck.getServerInfo().getName())) {
toSend = false;
}
}
if (toSend) {
sendPluginMessageServer(serverToCheck, "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 " + serverToCheck + ": "
+ cache.toString());
newSet.add(cache);
}
}
cachedVotes.put(serverToCheck, newSet);
}
}
}
}
public void checkOnlineVotes(Player player, String uuid, RegisteredServer serverToCheck) {
if (player != null && player.isActive() && cachedOnlineVotes.containsKey(uuid)) {
ArrayList<OfflineBungeeVote> c = cachedOnlineVotes.get(uuid);
if (!c.isEmpty()) {
if (serverToCheck == null) {
serverToCheck = player.getCurrentServer().get().getServer();
}
if (!config.getBlockedServers().contains(serverToCheck.getServerInfo().getName())) {
for (OfflineBungeeVote cache : c) {
sendPluginMessageServer(serverToCheck, "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()) {
logger.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) {
logger.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) {
if (server.getPlayer(UUID.fromString(uuid)).isPresent()) {
Player p = server.getPlayer(UUID.fromString(uuid)).get();
if (p != null && p.isActive()) {
return p.getUsername();
}
}
return currentName;
}
public String getUUID(String playerName) {
if (server.getPlayer(playerName).isPresent()) {
Player p = server.getPlayer(playerName).get();
if (p != null && p.isActive()) {
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, int toAdd) {
for (Column d : cols) {
if (d.getName().equalsIgnoreCase(column)) {
DataValue value = d.getValue();
int num = 0;
if (value.isInt()) {
num = value.getInt();
} else if (value.isString()) {
try {
num = Integer.parseInt(value.getString());
} catch (Exception e) {
}
}
return num + toAdd;
}
}
return toAdd;
}
private void loadMysql() {
mysql = new VelocityMySQL("VotingPlugin_Users", config) {
@Override
public void severe(String str) {
getLogger().error(str);
}
@Override
public void debug(SQLException e) {
if (config.getDebug()) {
e.printStackTrace();
}
}
};
// 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");
}
@Subscribe
public void onPluginMessagingReceived(PluginMessageEvent event) {
if (event.getIdentifier().getId().equals(CHANNEL.getId())) {
ByteArrayInputStream instream = new ByteArrayInputStream(event.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();
logger.info("Status okay for " + server);
return;
} else if (subchannel.equalsIgnoreCase("login")) {
String player = in.readUTF();
debug("Login: " + player);
Player p = server.getPlayer(player).get();
checkCachedVotes(p.getCurrentServer().get().getServer());
checkOnlineVotes(p, p.getUniqueId().toString(), p.getCurrentServer().get().getServer());
return;
} else {
// reforward message
out.writeUTF(subchannel);
out.writeInt(size);
for (int i = 0; i < size; i++) {
out.writeUTF(in.readUTF());
}
for (RegisteredServer send : server.getAllServers()) {
if (send.getPlayersConnected().size() > 0) {
send.sendPluginMessage(CHANNEL, outstream.toByteArray());
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
@Subscribe
public void onProxyDisable(ProxyShutdownEvent event) {
if (method.equals(BungeeMethod.PLUGINMESSAGING)) {
logger.info("VotingPlugin saving vote cache: " + cachedVotes.size() + "/" + cachedOnlineVotes.size());
for (Entry<RegisteredServer, ArrayList<OfflineBungeeVote>> entry : cachedVotes.entrySet()) {
RegisteredServer server = entry.getKey();
int num = 0;
for (OfflineBungeeVote voteData : entry.getValue()) {
voteCacheFile.addVote(server.getServerInfo().getName(), 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++;
}
}
voteCacheFile.save();
}
nonVotedPlayersCache.save();
logger.info("VotingPlugin disabled");
}
@Subscribe
public void onProxyInitialization(ProxyInitializeEvent event) {
File configFile = new File(dataDirectory.toFile(), "bungeeconfig.yml");
configFile.getParentFile().mkdirs();
if (!configFile.exists()) {
try {
configFile.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
InputStream toCopyStream = VotingPluginVelocity.class.getClassLoader()
.getResourceAsStream("bungeeconfig.yml");
try (FileOutputStream fos = new FileOutputStream(configFile)) {
byte[] buf = new byte[2048];
int r;
while (-1 != (r = toCopyStream.read(buf))) {
fos.write(buf, 0, r);
}
} catch (IOException e) {
e.printStackTrace();
}
}
config = new Config(configFile);
server.getChannelRegistrar().register(CHANNEL);
method = BungeeMethod.getByName(config.getBungeeMethod());
boolean mysqlLoaded = true;
try {
if (!config.getString(config.getNode("Host"), "").isEmpty()) {
loadMysql();
} else {
mysqlLoaded = false;
logger.error("MySQL settings not set in bungeeconfig.yml");
}
} catch (Exception e) {
mysqlLoaded = false;
e.printStackTrace();
}
CommandMeta meta = server.getCommandManager().metaBuilder("votingpluginbungee")
// Specify other aliases (optional)
.aliases("vpb").build();
server.getCommandManager().register(meta, new VotingPluginVelocityCommand(this));
if (mysqlLoaded) {
if (method.equals(BungeeMethod.MYSQL)) {
// this.getProxy().registerChannel("vp:vp");
} else if (method.equals(BungeeMethod.PLUGINMESSAGING)) {
voteCacheFile = new VoteCache(new File(dataDirectory.toFile(), "votecache.yml"));
nonVotedPlayersCache = new NonVotedPlayersCache(
new File(dataDirectory.toFile(), "nonvotedplayerscache.yml"), this);
try {
for (String serverToCheck : voteCacheFile.getServers()) {
ArrayList<OfflineBungeeVote> vote = new ArrayList<OfflineBungeeVote>();
for (String num : voteCacheFile.getServerVotes(serverToCheck)) {
ConfigurationNode data = voteCacheFile.getServerVotes(serverToCheck, num);
vote.add(new OfflineBungeeVote(data.getNode("Name").getString(),
data.getNode("UUID").getString(), data.getNode("Service").getString(),
data.getNode("Time").getLong(), data.getNode("Real").getBoolean(),
data.getNode("TEXT").getString()));
}
cachedVotes.put(server.getServer(serverToCheck).get(), vote);
}
} catch (Exception e) {
e.printStackTrace();
}
try {
for (String player : voteCacheFile.getPlayers()) {
ArrayList<OfflineBungeeVote> vote = new ArrayList<OfflineBungeeVote>();
for (String num : voteCacheFile.getOnlineVotes(player)) {
ConfigurationNode data = voteCacheFile.getOnlineVotes(player, num);
vote.add(new OfflineBungeeVote(data.getNode("Name").getString(),
data.getNode("UUID").getString(), data.getNode("Service").getString(),
data.getNode("Time").getLong(), data.getNode("Real").getBoolean(),
data.getNode("TEXT").getString()));
}
cachedOnlineVotes.put(player, vote);
}
} catch (Exception e) {
e.printStackTrace();
}
voteCacheFile.clearData();
server.getScheduler().buildTask(this, () -> {
for (RegisteredServer server : cachedVotes.keySet()) {
checkCachedVotes(server);
}
for (String player : cachedOnlineVotes.keySet()) {
checkOnlineVotes(server.getPlayer(UUID.fromString(player)).get(), player, null);
}
}).delay(15L, TimeUnit.SECONDS).repeat(30l, TimeUnit.SECONDS).schedule();
server.getScheduler().buildTask(this, () -> {
if (nonVotedPlayersCache != null) {
debug("Checking nonvotedplayerscache.yml...");
nonVotedPlayersCache.check();
}
}).delay(1L, TimeUnit.MINUTES).repeat(60l, TimeUnit.MINUTES).schedule();
} else if (method.equals(BungeeMethod.SOCKETS)) {
encryptionHandler = new EncryptionHandler(new File(dataDirectory.toFile(), "secretkey.key"));
socketHandler = new SocketHandler(
server.getPluginManager().getPlugin("votingplugin").get().getDescription().getVersion().get(),
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];
logger.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)) {
ConfigurationNode d = config.getSpigotServerConfiguration(s);
clientHandles.put(s, new ClientHandler(d.getNode("Host").getString(""),
d.getNode("Port").getInt(1298), encryptionHandler, config.getDebug()));
}
}
}
}
try {
getVersionFile();
if (versionFile != null) {
versionFile.delete();
versionFile.getParentFile().delete();
}
} catch (Exception e) {
e.printStackTrace();
}
Metrics metrics = metricsFactory.make(this, 11547);
metrics.addCustomChart(new SimplePie("bungee_method", () -> getConfig().getBungeeMethod().toString()));
metrics.addCustomChart(new SimplePie("sendtoallservers", () -> "" + getConfig().getSendVotesToAllServers()));
metrics.addCustomChart(new SimplePie("allowunjoined", () -> "" + getConfig().getAllowUnJoined()));
metrics.addCustomChart(new SimplePie("pointsonvote", () -> "" + getConfig().getPointsOnVote()));
metrics.addCustomChart(new SimplePie("bungeemanagetotals", () -> "" + getConfig().getBungeeManageTotals()));
metrics.addCustomChart(new SimplePie("waitforuseronline", () -> "" + getConfig().getWaitForUserOnline()));
metrics.addCustomChart(new SimplePie("plugin_version", () -> "" + version));
logger.info("VotingPlugin velocity loaded, method: " + method.toString() + ", PluginMessagingVersion: "
+ BungeeVersion.getPluginMessageVersion() + ", Internal Jar Version: " + version);
}
private String version = "";
private File versionFile;
private void getVersionFile() {
try {
CodeSource src = this.getClass().getProtectionDomain().getCodeSource();
if (src != null) {
URL jar = src.getLocation();
ZipInputStream zip = null;
zip = new ZipInputStream(jar.openStream());
while (true) {
ZipEntry e = zip.getNextEntry();
if (e != null) {
String name = e.getName();
if (name.equals("votingpluginversion.yml")) {
Reader defConfigStream = new InputStreamReader(zip);
if (defConfigStream != null) {
versionFile = new File(dataDirectory.toFile(),
"tmp" + File.separator + "votingpluginversion.yml");
if (!versionFile.exists()) {
versionFile.getParentFile().mkdirs();
versionFile.createNewFile();
}
FileWriter fileWriter = new FileWriter(versionFile);
int charVal;
while ((charVal = defConfigStream.read()) != -1) {
fileWriter.append((char) charVal);
}
fileWriter.close();
YAMLConfigurationLoader loader = YAMLConfigurationLoader.builder().setFile(versionFile)
.build();
defConfigStream.close();
ConfigurationNode node = loader.load();
if (node != null) {
version = node.getNode("version").getString("");
}
return;
}
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
@Subscribe
public void onVotifierEvent(VotifierEvent event) {
server.getScheduler().buildTask(this, new Runnable() {
@Override
public void run() {
Vote vote = event.getVote();
String serviceSite = vote.getServiceName();
logger.info("Vote received " + vote.getUsername() + " from service site " + serviceSite);
if (serviceSite.isEmpty()) {
serviceSite = "Empty";
}
vote(vote.getUsername(), serviceSite, true);
}
});
}
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);
}
@Subscribe
public void playerServerConnected(ServerConnectedEvent event) {
checkCachedVotes(event.getServer());
checkOnlineVotes(event.getPlayer(), event.getPlayer().getUniqueId().toString(), event.getServer());
}
public void reload(boolean loadMySQL) {
config.reload();
if (loadMySQL) {
if (!config.getString(config.getNode("Host"), "").isEmpty()) {
loadMysql();
} else {
logger.error("MySQL settings not set in bungeeconfig.yml");
}
}
}
public void sendPluginMessageServer(RegisteredServer s, 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 (s.getPlayersConnected().size() > 0) {
s.sendPluginMessage(CHANNEL, byteOutStream.toByteArray());
}
out.close();
} catch (Exception e) {
e.printStackTrace();
}
debug("Sending plugin message " + s.getServerInfo().getName() + " " + 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
Player p = server.getPlayer(name).get();
String server = "";
if (p != null && p.isActive()) {
server = p.getCurrentServer().get().getServerInfo().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() {
if (method.equals(BungeeMethod.SOCKETS)) {
sendServerMessage("status");
} else if (method.equals(BungeeMethod.PLUGINMESSAGING)) {
for (RegisteredServer s : server.getAllServers()) {
if (!config.getBlockedServers().contains(s.getServerInfo().getName())) {
if (s.getPlayersConnected().size() == 0) {
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.getServerInfo().getName());
}
} else {
getLogger().info("Ignoring blocked server " + s);
}
}
}
}
public synchronized void vote(String player, String service, boolean realVote) {
try {
if (player == null || player.isEmpty()) {
logger.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 {
logger.info("Ignoring vote from " + player + " since player hasn't joined before");
return;
}
}
player = getProperName(uuid, player);
BungeeMessageData text = null;
if (getConfig().getBungeeManageTotals()) {
if (mysql == null) {
logger.error("Mysql is not loaded correctly, stopping vote processing");
return;
}
if (!mysql.getUuids().contains(uuid)) {
mysql.update(uuid, "PlayerName", new DataValueString(player));
}
ArrayList<Column> data = mysql.getExactQuery(new Column("uuid", new DataValueString(uuid)));
int allTimeTotal = getValue(data, "AllTimeTotal", 1);
int monthTotal = getValue(data, "MonthTotal", 1);
int weeklyTotal = getValue(data, "WeeklyTotal", 1);
int dailyTotal = getValue(data, "DailyTotal", 1);
int points = getValue(data, "Points", getConfig().getPointsOnVote());
int milestoneCount = getValue(data, "MilestoneCount", 1);
text = new BungeeMessageData(allTimeTotal, monthTotal, weeklyTotal, dailyTotal, points, milestoneCount);
ArrayList<Column> update = new ArrayList<Column>();
update.add(new Column("AllTimeTotal", new DataValueInt(allTimeTotal)));
update.add(new Column("MonthTotal", new DataValueInt(monthTotal)));
update.add(new Column("WeeklyTotal", new DataValueInt(weeklyTotal)));
update.add(new Column("DailyTotal", new DataValueInt(dailyTotal)));
update.add(new Column("Points", new DataValueInt(points)));
update.add(new Column("MilestoneCount", new DataValueInt(milestoneCount)));
debug("Setting totals " + text.toString());
mysql.update(uuid, update);
} 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 (RegisteredServer s : server.getAllServers()) {
if (!config.getBlockedServers().contains(s.getServerInfo().getName())) {
boolean forceCache = false;
Player p = null;
if (server.getPlayer(UUID.fromString(uuid)).isPresent()) {
p = server.getPlayer(UUID.fromString(uuid)).get();
}
if ((p == null || !p.isActive()) && getConfig().getWaitForUserOnline()) {
forceCache = true;
debug("Forcing vote to cache");
}
if (s.getPlayersConnected().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 {
Player p = server.getPlayer(UUID.fromString(uuid)).get();
if (p != null && p.isActive() && !config.getBlockedServers()
.contains(p.getCurrentServer().get().getServerInfo().getName())) {
sendPluginMessageServer(p.getCurrentServer().get().getServer(), "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);
}
for (RegisteredServer s : server.getAllServers()) {
sendPluginMessageServer(s, "VoteUpdate", uuid);
}
}
} else if (method.equals(BungeeMethod.SOCKETS)) {
sendSocketVote(player, service, text);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
@@ -0,0 +1,74 @@
package com.bencodez.votingplugin.bungee.velocity;
import com.bencodez.votingplugin.bungee.BungeeMethod;
import com.velocitypowered.api.command.CommandSource;
import com.velocitypowered.api.command.SimpleCommand;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
public class VotingPluginVelocityCommand implements SimpleCommand {
private VotingPluginVelocity plugin;
public VotingPluginVelocityCommand(VotingPluginVelocity plugin) {
this.plugin = plugin;
}
@Override
public void execute(final Invocation invocation) {
CommandSource source = invocation.source();
// Get the arguments after the command alias
String[] args = invocation.arguments();
if (args.length > 0) {
if (args[0].equalsIgnoreCase("reload")) {
plugin.reload(false);
source.sendMessage(Component.text("Reloading VotingPluginBungee").color(NamedTextColor.AQUA));
}
if (args[0].equalsIgnoreCase("reloadmysql")) {
plugin.reload(true);
source.sendMessage(Component.text("Reloading VotingPluginBungee MySQL").color(NamedTextColor.AQUA));
}
if (args[0].equalsIgnoreCase("vote")) {
if (args.length >= 2) {
String user = args[1];
String site = args[2];
plugin.vote(user, site, false);
source.sendMessage(Component.text("Sending vote").color(NamedTextColor.AQUA));
}
}
if (args[0].equalsIgnoreCase("status")) {
if (plugin.getMethod().equals(BungeeMethod.SOCKETS)) {
source.sendMessage(
Component.text("Checking status, waiting for response, check console, method: sockets")
.color(NamedTextColor.AQUA));
plugin.status();
} else if (plugin.getMethod().equals(BungeeMethod.PLUGINMESSAGING)) {
source.sendMessage(Component
.text("Checking status, waiting for response, check console, method: pluginmessaging")
.color(NamedTextColor.AQUA));
plugin.status();
} else {
source.sendMessage(Component.text("Not using socket/pluginmessage method, command unavailable")
.color(NamedTextColor.AQUA));
}
}
if (args[0].equalsIgnoreCase("help")) {
String[] msg = new String[4];
msg[0] = "votingpluginbungee reload - Reload plugin";
msg[1] = "votingpluginbungee reloadmysql - Reload plugin including mysql";
msg[2] = "votingpluginbungee vote (player) (servicesite) - Send bungee vote";
msg[3] = "votingpluginbungee status - Check socket connection status";
for (String m : msg) {
source.sendMessage(Component.text(m).color(NamedTextColor.AQUA));
}
}
}
}
@Override
public boolean hasPermission(final Invocation invocation) {
return invocation.source().hasPermission("votingpluginbungee.admin");
}
}
@@ -1,11 +1,10 @@
package com.bencodez.votingplugin.commands;
import java.io.File;
import java.io.IOException;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
import java.util.UUID;
import java.util.regex.Pattern;
import org.bukkit.Bukkit;
@@ -32,8 +31,7 @@ import com.bencodez.advancedcore.api.misc.PlayerUtils;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import com.bencodez.advancedcore.api.rewards.RewardOptions;
import com.bencodez.advancedcore.api.updater.Updater;
import com.bencodez.advancedcore.api.user.UUID;
import com.bencodez.advancedcore.api.user.UserStorage;
import com.bencodez.advancedcore.api.user.userstorage.DataType;
import com.bencodez.advancedcore.api.valuerequest.ValueRequest;
import com.bencodez.advancedcore.api.valuerequest.listeners.BooleanListener;
import com.bencodez.advancedcore.api.valuerequest.listeners.StringListener;
@@ -41,10 +39,16 @@ import com.bencodez.advancedcore.command.gui.UserGUI;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.commands.executers.CommandAliases;
import com.bencodez.votingplugin.commands.gui.AdminGUI;
import com.bencodez.votingplugin.commands.gui.admin.AdminVoteBungeeSettings;
import com.bencodez.votingplugin.commands.gui.admin.AdminVoteHelp;
import com.bencodez.votingplugin.commands.gui.admin.AdminVotePerms;
import com.bencodez.votingplugin.commands.gui.admin.AdminVotePlaceholders;
import com.bencodez.votingplugin.commands.gui.admin.AdminVotePlaceholdersPlayer;
import com.bencodez.votingplugin.commands.gui.admin.AdminVoteVoteParty;
import com.bencodez.votingplugin.commands.gui.admin.AdminVoteVotePlayer;
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.commands.gui.player.VoteBest;
import com.bencodez.votingplugin.commands.gui.player.VoteGUI;
import com.bencodez.votingplugin.commands.gui.player.VoteHelp;
@@ -65,7 +69,6 @@ import com.bencodez.votingplugin.test.VoteTester;
import com.bencodez.votingplugin.topvoter.TopVoter;
import com.bencodez.votingplugin.user.UserManager;
import com.bencodez.votingplugin.user.VotingPluginUser;
import com.tchristofferson.configupdater.ConfigUpdater;
// TODO: Auto-generated Javadoc
/**
@@ -99,22 +102,36 @@ public class CommandLoader {
public BInventoryButton getBackButton(VotingPluginUser user) {
ConfigurationSection sec = plugin.getGui().getCHESTBackButton();
boolean a = false;
ItemBuilder item;
if (sec != null) {
item = new ItemBuilder(sec);
a = sec.getBoolean("OpenVoteURL", false);
} else {
item = new ItemBuilder(Material.BARRIER, 1).setName("&8Back to VoteGUI");
}
final boolean openVoteURL = a;
BInventoryButton b = new BInventoryButton(item) {
@Override
public void onClick(ClickEvent event) {
new VoteGUI(plugin, event.getWhoClicked(), user)
.open(GUIMethod.valueOf(plugin.getGui().getGuiMethodGUI().toUpperCase()));
if (!openVoteURL) {
new VoteGUI(plugin, event.getWhoClicked(), user)
.open(GUIMethod.valueOf(plugin.getGui().getGuiMethodGUI().toUpperCase()));
} else {
new VoteURL(plugin, event.getWhoClicked(), user, true).open();
}
}
};
// set item to end of the GUI
if (sec != null && sec.getBoolean("EndOfGUI")) {
b.setSlot(-2);
}
if (!plugin.getConfigFile().isAlwaysCloseInventory()) {
b.dontClose();
}
@@ -246,14 +263,29 @@ public class CommandLoader {
public void execute(CommandSender sender, String[] args) {
sendMessage(sender, "&cStarting...");
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(UUID.fromString(uuid));
user.dontCache();
user.setMilestoneCount(user.getTotal(TopVoter.AllTime));
}
sendMessage(sender, "&cFinished");
sendMessage(sender, "&cFinished sync milestonecount with all time total");
}
});
plugin.getAdminVoteCommand()
.add(new CommandHandler(new String[] { "ResetMilestoneCount" },
"VotingPlugin.Commands.AdminVote.ResetMilestoneCount|" + adminPerm,
"Resets milestone count to alltimetotal") {
@Override
public void execute(CommandSender sender, String[] args) {
sendMessage(sender, "&cStarting to clear milestonecounts...");
plugin.getTopVoterHandler().resetMilestoneCount();
sendMessage(sender, "&cFinished");
}
});
plugin.getAdminVoteCommand()
.add(new CommandHandler(new String[] { "ResyncMilestonesAlreadyGiven" },
"VotingPlugin.Commands.AdminVote.ResyncMilestonesGiven|" + adminPerm,
@@ -272,7 +304,9 @@ public class CommandLoader {
}
}
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
VotingPluginUser user = UserManager.getInstance()
.getVotingPluginUser(UUID.fromString(uuid));
user.dontCache();
int milestoneCount = user.getMilestoneCount();
for (int num : nums) {
if (milestoneCount >= num) {
@@ -300,27 +334,27 @@ public class CommandLoader {
@Override
public void execute(CommandSender sender, String[] args) {
sendMessage(sender, "&cStarting...");
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
user.setPoints(0);
}
plugin.getUserManager().removeAllKeyValues("Points", DataType.INTEGER);
plugin.getUserManager().getDataManager().clearCache();
sendMessage(sender, "&cFinished");
}
});
plugin.getAdminVoteCommand().add(new CommandHandler(new String[] { "ResyncMilestones", "(player)" },
"VotingPlugin.Commands.AdminVote.SetResyncMilestones|" + adminPerm, "Resync Milestones") {
plugin.getAdminVoteCommand()
.add(new CommandHandler(new String[] { "ResyncMilestones", "(player)" },
"VotingPlugin.Commands.AdminVote.SetResyncMilestones|" + adminPerm,
"Resync Milestones to alltimetotal for player") {
@Override
public void execute(CommandSender sender, String[] args) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(args[1]);
user.setMilestoneCount(user.getTotal(TopVoter.AllTime));
@Override
public void execute(CommandSender sender, String[] args) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(args[1]);
user.setMilestoneCount(user.getTotal(TopVoter.AllTime));
sendMessage(sender, "&cResynced milestones for " + args[1]);
sendMessage(sender, "&cResynced milestones for " + args[1]);
}
});
}
});
plugin.getAdminVoteCommand()
.add(new CommandHandler(new String[] { "User", "(player)", "AddPoints", "(number)" },
@@ -356,7 +390,6 @@ public class CommandLoader {
@Override
public void execute(CommandSender sender, String[] args) {
new AdminVoteHelp(plugin, sender, 1).open();
;
}
});
@@ -373,7 +406,7 @@ public class CommandLoader {
for (String serviceSite : serviceSites) {
boolean hasSite = plugin.hasVoteSite(serviceSite);
if (hasSite) {
String siteName = plugin.getVoteSiteName(serviceSite);
String siteName = plugin.getVoteSiteName(true, serviceSite);
sendMessage(sender, serviceSite + " : Current site = " + siteName);
} else {
sendMessage(sender, serviceSite
@@ -398,6 +431,50 @@ public class CommandLoader {
}
});
plugin.getAdminVoteCommand().add(new CommandHandler(new String[] { "Edit", "BungeeSettings" },
"VotingPlugin.Commands.AdminVote.Edit.BungeeSettings", "Edit BungeeSettings.yml", false) {
@Override
public void execute(CommandSender sender, String[] args) {
new AdminVoteBungeeSettings(plugin, sender).open(GUIMethod.CHEST);
}
});
plugin.getAdminVoteCommand().add(new CommandHandler(new String[] { "Edit", "VoteShop" },
"VotingPlugin.Commands.AdminVote.Edit.VoteShop", "Edit VoteShop", false) {
@Override
public void execute(CommandSender sender, String[] args) {
new AdminVoteVoteShop(plugin, sender).open(GUIMethod.CHEST);
}
});
plugin.getAdminVoteCommand().add(new CommandHandler(new String[] { "Edit", "MileStones" },
"VotingPlugin.Commands.AdminVote.Edit.MileStones", "Edit milestones rewards", false) {
@Override
public void execute(CommandSender sender, String[] args) {
new AdminVoteMilestones(plugin, sender).open(GUIMethod.CHEST);
}
});
plugin.getAdminVoteCommand().add(new CommandHandler(new String[] { "Edit", "Cumulative" },
"VotingPlugin.Commands.AdminVote.Edit.Cumulative", "Edit cumulative rewards", false) {
@Override
public void execute(CommandSender sender, String[] args) {
new AdminVoteCumulative(plugin, sender).open(GUIMethod.CHEST);
}
});
plugin.getAdminVoteCommand().add(new CommandHandler(new String[] { "Edit", "VoteParty" },
"VotingPlugin.Commands.AdminVote.Edit.VoteParty", "Edit voteparty", false) {
@Override
public void execute(CommandSender sender, String[] args) {
new AdminVoteVoteParty(plugin, sender).open(GUIMethod.CHEST);
}
});
plugin.getAdminVoteCommand().add(new CommandHandler(new String[] { "Perms" },
"VotingPlugin.Commands.AdminVote.Perms|" + adminPerm, "List permissions") {
@@ -573,7 +650,7 @@ public class CommandLoader {
@Override
public void execute(CommandSender sender, String[] args) {
if (sender instanceof Player) {
new AdminGUI(plugin).openAdminGUIVoteSiteSite((Player) sender, plugin.getVoteSite(args[1]));
new AdminGUI(plugin).openAdminGUIVoteSiteSite((Player) sender, plugin.getVoteSite(args[1], false));
} else {
sender.sendMessage("Must be a player to do this");
}
@@ -599,7 +676,7 @@ public class CommandLoader {
try {
sender.sendMessage(ChatColor.GREEN + "PlayerName of player " + ChatColor.DARK_GREEN + args[1]
+ ChatColor.GREEN + " is: " + PlayerUtils.getInstance().getPlayerName(
UserManager.getInstance().getVotingPluginUser(new UUID(args[1])), args[1]));
UserManager.getInstance().getVotingPluginUser(UUID.fromString(args[1])), args[1]));
} catch (IllegalArgumentException e) {
sendMessage(sender, "&cInvalid uuid");
}
@@ -618,16 +695,16 @@ public class CommandLoader {
return;
}
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
user.clearTotals();
for (TopVoter top : TopVoter.values()) {
plugin.getUserManager().removeAllKeyValues(top.getColumnName(), DataType.INTEGER);
}
plugin.getUserManager().getDataManager().clearCache();
sender.sendMessage(StringParser.getInstance().colorize("&cCleared totals for everyone"));
}
});
plugin.getAdminVoteCommand().add(new CommandHandler(new String[] { "ClearOfflineRewards" },
"VotingPlugin.Commands.AdminVote.ClearOfflineRewards|" + adminPerm, "Reset offline votes/rewards") {
plugin.getAdminVoteCommand().add(new CommandHandler(new String[] { "ClearOfflineVoteRewards" },
"VotingPlugin.Commands.AdminVote.ClearOfflineVoteRewards|" + adminPerm, "Reset offline votes/rewards") {
@Override
public void execute(CommandSender sender, String[] args) {
@@ -636,34 +713,52 @@ public class CommandLoader {
StringParser.getInstance().colorize("&cThis command can not be done from ingame"));
return;
}
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
user.clearOfflineRewards();
}
sender.sendMessage(StringParser.getInstance().colorize("&cCleared totals for everyone"));
plugin.getUserManager().removeAllKeyValues("OfflineVotes", DataType.STRING);
plugin.getUserManager().removeAllKeyValues(plugin.getUserManager().getOfflineRewardsPath(),
DataType.STRING);
plugin.getUserManager().getDataManager().clearCache();
sender.sendMessage(StringParser.getInstance().colorize("&cCleared offline votes/rewards"));
}
});
plugin.getAdminVoteCommand()
.add(new CommandHandler(new String[] { "ConvertFromData", "(userstorage)" },
"VotingPlugin.Commands.AdminVote.ConvertFromData",
"Convert from selected user storage to current user storage") {
.add(new CommandHandler(new String[] { "User", "(player)", "SetVoteStreak", "DAY", "(number)" },
"VotingPlugin.Commands.AdminVote.SetVoteStreak.Day|" + adminPerm, "Set votestreak for player") {
@Override
public void execute(CommandSender sender, String[] args) {
if (sender instanceof Player) {
sender.sendMessage(StringParser.getInstance().colorize("&cThis can not be done ingame"));
return;
}
try {
sender.sendMessage("Starting to convert");
UserStorage prevStorage = UserStorage.valueOf(args[1].toUpperCase());
plugin.convertDataStorage(prevStorage, VotingPluginMain.plugin.getStorageType());
sender.sendMessage("Finished converting!");
} catch (Exception ex) {
ex.printStackTrace();
}
UserManager.getInstance().getVotingPluginUser(args[1])
.setDayVoteStreak(Integer.parseInt(args[4]));
sender.sendMessage(StringParser.getInstance()
.colorize("&cSet votestreak day for '" + args[1] + "' to " + args[4]));
}
});
plugin.getAdminVoteCommand()
.add(new CommandHandler(new String[] { "User", "(player)", "SetVoteStreak", "WEEK", "(number)" },
"VotingPlugin.Commands.AdminVote.SetVoteStreak.Week|" + adminPerm,
"Set votestreak for player") {
@Override
public void execute(CommandSender sender, String[] args) {
UserManager.getInstance().getVotingPluginUser(args[1])
.setWeekVoteStreak(Integer.parseInt(args[4]));
sender.sendMessage(StringParser.getInstance()
.colorize("&cSet votestreak week for '" + args[1] + "' to " + args[4]));
}
});
plugin.getAdminVoteCommand()
.add(new CommandHandler(new String[] { "User", "(player)", "SetVoteStreak", "MONTH", "(number)" },
"VotingPlugin.Commands.AdminVote.SetVoteStreak.Month|" + adminPerm,
"Set votestreak for player") {
@Override
public void execute(CommandSender sender, String[] args) {
UserManager.getInstance().getVotingPluginUser(args[1])
.setMonthVoteStreak(Integer.parseInt(args[4]));
sender.sendMessage(StringParser.getInstance()
.colorize("&cSet votestreak month for '" + args[1] + "' to " + args[4]));
}
});
@@ -716,6 +811,7 @@ public class CommandLoader {
public void execute(CommandSender sender, String[] args) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(args[1]);
user.setMilestoneCount(user.getMilestoneCount() + Integer.parseInt(args[3]));
plugin.getSpecialRewards().checkMilestone(user, null, false);
sender.sendMessage(
StringParser.getInstance().colorize("&cAdded milestonecount for " + args[1]));
}
@@ -734,12 +830,52 @@ public class CommandLoader {
}
});
plugin.getAdminVoteCommand()
.add(new CommandHandler(new String[] { "User", "(player)", "ClearGottenMilestones" },
"VotingPlugin.Commands.AdminVote.ClearGottenMilestones|" + adminPerm,
"Clears received milestones") {
@Override
public void execute(CommandSender sender, String[] args) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(args[1]);
user.setHasGottenMilestone(new HashMap<String, Boolean>());
sender.sendMessage(
StringParser.getInstance().colorize("&cClearing gotten milestones for " + args[1]));
}
});
plugin.getAdminVoteCommand().add(new CommandHandler(new String[] { "Vote", "(player)", "All" },
"VotingPlugin.Commands.AdminVote.Vote|" + adminPerm, "Trigger manual vote") {
@Override
public void execute(CommandSender sender, String[] args) {
sendMessage(sender, "&cTriggering vote for all voting sites...");
for (VoteSite site : plugin.getVoteSites()) {
PlayerVoteEvent voteEvent = new PlayerVoteEvent(site, args[1], site.getServiceSite(), false);
if (voteEvent.getVoteSite() != null) {
if (!voteEvent.getVoteSite().isVaidServiceSite()) {
sendMessage(sender,
"&cPossible issue with service site, has the server gotten the vote from "
+ voteEvent.getServiceSite() + "?");
}
}
plugin.getServer().getPluginManager().callEvent(voteEvent);
}
if (plugin.isYmlError()) {
sendMessage(sender, "&3Detected yml error, please check server log for details");
}
}
});
plugin.getAdminVoteCommand().add(new CommandHandler(new String[] { "Vote", "(player)", "(Sitename)" },
"VotingPlugin.Commands.AdminVote.Vote|" + adminPerm, "Trigger manual vote") {
@Override
public void execute(CommandSender sender, String[] args) {
PlayerVoteEvent voteEvent = new PlayerVoteEvent(plugin.getVoteSite(args[2]), args[1], args[2], false);
PlayerVoteEvent voteEvent = new PlayerVoteEvent(plugin.getVoteSite(args[2], true), args[1], args[2],
false);
sendMessage(sender, "&cTriggering vote...");
if (voteEvent.getVoteSite() != null) {
if (!voteEvent.getVoteSite().isVaidServiceSite()) {
@@ -750,8 +886,49 @@ public class CommandLoader {
plugin.getServer().getPluginManager().callEvent(voteEvent);
if (plugin.isYmlError()) {
sendMessage(sender,
"&4" + plugin.getName() + " v" + plugin.getDescription().getVersion() + " reloaded!");
sendMessage(sender, "&3Detected yml error, please check server log for details");
}
}
});
plugin.getAdminVoteCommand().add(new CommandHandler(new String[] { "Vote", "(player)", },
"VotingPlugin.Commands.AdminVote.Vote|" + adminPerm, "Trigger manual vote via GUI", false) {
@Override
public void execute(CommandSender sender, String[] args) {
new AdminVoteVotePlayer(plugin, sender, args[1]).open();
}
});
plugin.getAdminVoteCommand().add(new CommandHandler(new String[] { "Vote" },
"VotingPlugin.Commands.AdminVote.Vote|" + adminPerm, "Manual vote syntax") {
@Override
public void execute(CommandSender sender, String[] args) {
sendMessage(sender, "&aUse /av vote (player) (site)");
}
});
plugin.getAdminVoteCommand().add(new CommandHandler(new String[] { "User", "(Player)", "ForceVote", "All" },
"VotingPlugin.Commands.AdminVote.Vote|" + adminPerm, "Trigger manual vote") {
@Override
public void execute(CommandSender sender, String[] args) {
sendMessage(sender, "&cTriggering vote for all voting sites...");
for (VoteSite site : plugin.getVoteSites()) {
PlayerVoteEvent voteEvent = new PlayerVoteEvent(site, args[1], site.getServiceSite(), false);
if (voteEvent.getVoteSite() != null) {
if (!voteEvent.getVoteSite().isVaidServiceSite()) {
sendMessage(sender,
"&cPossible issue with service site, has the server gotten the vote from "
+ voteEvent.getServiceSite() + "?");
}
}
plugin.getServer().getPluginManager().callEvent(voteEvent);
}
if (plugin.isYmlError()) {
sendMessage(sender, "&3Detected yml error, please check server log for details");
}
@@ -764,8 +941,8 @@ public class CommandLoader {
@Override
public void execute(CommandSender sender, String[] args) {
PlayerVoteEvent voteEvent = new PlayerVoteEvent(plugin.getVoteSite(args[3]), args[1], args[3],
false);
PlayerVoteEvent voteEvent = new PlayerVoteEvent(plugin.getVoteSite(args[3], true), args[1],
args[3], false);
sendMessage(sender, "&cTriggering vote...");
if (voteEvent.getVoteSite() != null) {
if (!voteEvent.getVoteSite().isVaidServiceSite()) {
@@ -803,26 +980,6 @@ public class CommandLoader {
}
});
plugin.getAdminVoteCommand().add(new CommandHandler(new String[] { "Config", "Update" },
"VotingPlugin.Commands.AdminVote.Config.Edit|" + adminPerm, "Updates config with missing values") {
@Override
public void execute(CommandSender sender, String[] args) {
ArrayList<String> ignoreSections = new ArrayList<String>();
ignoreSections.add("VoteReminding");
File file = new File(plugin.getDataFolder(), "Config.yml");
try {
ConfigUpdater.update(plugin, "Config.yml", file, ignoreSections);
} catch (IOException e) {
e.printStackTrace();
}
plugin.getConfigFile().reloadData();
plugin.getConfigFile().loadValues();
sendMessage(sender, "&cUpdated config with new values");
}
});
plugin.getAdminVoteCommand()
.add(new CommandHandler(new String[] { "Config", "TempExtraDebug" },
"VotingPlugin.Commands.AdminVote.Config.Edit|" + adminPerm,
@@ -840,7 +997,7 @@ public class CommandLoader {
@Override
public void execute(CommandSender sender, String[] args) {
String voteSite = plugin.getVoteSiteName(args[1]);
String voteSite = plugin.getVoteSiteName(true, args[1]);
String serviceSite = args[3];
plugin.getConfigVoteSites().setServiceSite(voteSite, serviceSite);
sender.sendMessage(StringParser.getInstance()
@@ -854,7 +1011,7 @@ public class CommandLoader {
@Override
public void execute(CommandSender sender, String[] args) {
String voteSite = plugin.getVoteSiteName(args[1]);
String voteSite = plugin.getVoteSiteName(true, args[1]);
String url = args[3];
plugin.getConfigVoteSites().setVoteURL(voteSite, url);
sender.sendMessage(StringParser.getInstance()
@@ -868,7 +1025,7 @@ public class CommandLoader {
@Override
public void execute(CommandSender sender, String[] args) {
String voteSite = plugin.getVoteSiteName(args[1]);
String voteSite = plugin.getVoteSiteName(true, args[1]);
int value = Integer.parseInt(args[3]);
plugin.getConfigVoteSites().setPriority(voteSite, value);
sender.sendMessage(StringParser.getInstance()
@@ -883,7 +1040,7 @@ public class CommandLoader {
@Override
public void execute(CommandSender sender, String[] args) {
String voteSite = plugin.getVoteSiteName(args[1]);
String voteSite = plugin.getVoteSiteName(true, args[1]);
int delay = Integer.parseInt(args[3]);
plugin.getConfigVoteSites().setVoteDelay(voteSite, delay);
sender.sendMessage(StringParser.getInstance()
@@ -939,7 +1096,7 @@ public class CommandLoader {
@Override
public void execute(CommandSender sender, String[] args) {
String voteSite = plugin.getVoteSiteName(args[1]);
String voteSite = plugin.getVoteSiteName(false, args[1]);
boolean value = Boolean.parseBoolean(args[3]);
plugin.getConfigVoteSites().setEnabled(voteSite, value);
@@ -1003,11 +1160,9 @@ public class CommandLoader {
@Override
public void execute(CommandSender sender, String[] args) {
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
user.setOfflineVotes(new ArrayList<String>());
}
sender.sendMessage(StringParser.getInstance().colorize("&cCleared"));
plugin.getUserManager().removeAllKeyValues("OfflineVotes", DataType.STRING);
plugin.getUserManager().getDataManager().clearCache();
sender.sendMessage(StringParser.getInstance().colorize("&cOffline votes Cleared"));
}
});
@@ -1055,14 +1210,14 @@ public class CommandLoader {
@Override
public void execute(CommandSender sender, String[] args) {
plugin.getVoteParty().giveRewards();
plugin.getVoteParty().giveRewards(plugin.getBungeeSettings().isUseBungeecoord());
}
});
plugin.getAdminVoteCommand()
.add(new CommandHandler(new String[] { "VotePartyExtraRequired", "(Number)" },
"VotingPlugin.Commands.AdminVote.VoteParty.SetExtraRequired|" + adminPerm,
"Force a voteparty reward, resets vote count") {
"Set VotePartyExtraRequired value") {
@Override
public void execute(CommandSender sender, String[] args) {
@@ -1091,7 +1246,8 @@ public class CommandLoader {
@Override
public void execute(CommandSender sender, String[] args) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(args[1]);
plugin.getSpecialRewards().giveMilestoneVoteReward(user, user.isOnline(), parseInt(args[3]));
plugin.getSpecialRewards().giveMilestoneVoteReward(user, user.isOnline(), parseInt(args[3]),
plugin.getBungeeSettings().isUseBungeecoord());
sendMessage(sender, "&cMilestone " + args[3] + " forced");
}
});
@@ -1152,7 +1308,7 @@ public class CommandLoader {
public void execute(CommandSender sender, String[] args) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(args[1]);
plugin.getSpecialRewards().giveVoteStreakReward(user, user.isOnline(), str, args[4],
parseInt(args[4]));
parseInt(args[4]), plugin.getBungeeSettings().isUseBungeecoord());
sendMessage(sender, "&cVoteStreak " + str + " " + args[4] + " forced");
}
});
@@ -1165,7 +1321,8 @@ public class CommandLoader {
@Override
public void execute(CommandSender sender, String[] args) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(args[1]);
plugin.getSpecialRewards().giveCumulativeVoteReward(user, user.isOnline(), parseInt(args[3]));
plugin.getSpecialRewards().giveCumulativeVoteReward(user, user.isOnline(), parseInt(args[3]),
plugin.getBungeeSettings().isUseBungeecoord());
sendMessage(sender, "&cCumulative " + args[3] + " forced");
}
});
@@ -1176,7 +1333,8 @@ public class CommandLoader {
@Override
public void execute(CommandSender sender, String[] args) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(args[1]);
plugin.getSpecialRewards().giveAllSitesRewards(user, user.isOnline());
plugin.getSpecialRewards().giveAllSitesRewards(user, user.isOnline(),
plugin.getBungeeSettings().isUseBungeecoord());
sendMessage(sender, "&cAllSites forced");
}
});
@@ -1187,11 +1345,24 @@ public class CommandLoader {
@Override
public void execute(CommandSender sender, String[] args) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(args[1]);
plugin.getSpecialRewards().giveFirstVoteRewards(user, user.isOnline());
plugin.getSpecialRewards().giveFirstVoteRewards(user, user.isOnline(),
plugin.getBungeeSettings().isUseBungeecoord());
sendMessage(sender, "&cFirstVote forced");
}
});
plugin.getAdminVoteCommand().add(new CommandHandler(new String[] { "User", "(player)", "ForceFirstVoteToday" },
"VotingPlugin.Commands.AdminVote.ForceFirstVoteToday|" + adminPerm, "Force a firstvotetoday reward") {
@Override
public void execute(CommandSender sender, String[] args) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(args[1]);
plugin.getSpecialRewards().giveFirstVoteTodayRewards(user, user.isOnline(),
plugin.getBungeeSettings().isUseBungeecoord());
sendMessage(sender, "&cFirstVoteToday forced");
}
});
plugin.getAdminVoteCommand()
.add(new CommandHandler(new String[] { "Placeholders", "(player)" },
"VotingPlugin.Commands.AdminVote.Placeholders.Players|" + adminPerm,
@@ -1232,32 +1403,39 @@ public class CommandLoader {
return;
}
for (CommandHandler cmdHandle : plugin.getVoteCommand()) {
if (cmdHandle.getArgs().length > 0) {
int argLength = cmdHandle.getArgs().length;
String arg0 = "";
if (argLength > 0) {
arg0 = cmdHandle.getArgs()[0];
}
String[] perms = cmdHandle.getPerm().split(Pattern.quote("|"));
try {
if (perms.length > 1) {
// has another perm
plugin.devDebug("Adding child perm " + perms[0] + " to " + perms[1] + " from /vote" + arg0);
Permission p = Bukkit.getPluginManager().getPermission(perms[1]);
p.getChildren().put(perms[0], true);
p.recalculatePermissibles();
}
} catch (Exception e) {
plugin.debug("Failed to set permission for /vote" + arg0);
}
if (argLength > 0) {
String[] args = cmdHandle.getArgs()[0].split("&");
for (String arg : args) {
commands.put("vote" + arg, cmdHandle);
try {
String[] perms = cmdHandle.getPerm().split(Pattern.quote("|"));
if (perms.length > 1) {
// has another perm
plugin.devDebug("Adding child perm " + perms[0] + " to " + perms[1]);
Permission p = Bukkit.getPluginManager().getPermission(perms[1]);
p.getChildren().put(perms[0], true);
p.recalculatePermissibles();
}
} catch (Exception e) {
plugin.debug("Failed to set permission for /vote" + arg);
}
try {
plugin.getCommand("vote" + arg).setExecutor(new CommandAliases(cmdHandle, false));
plugin.getCommand("vote" + arg)
.setTabCompleter(new AliasesTabCompleter().setCMDHandle(cmdHandle, false));
plugin.getCommand("vote" + arg).setPermission(cmdHandle.getPerm().split(Pattern.quote("|"))[0]);
String currentPerm = plugin.getCommand("vote" + arg).getPermission();
if (currentPerm == null || currentPerm.length() > perms[0].length()) {
plugin.getCommand("vote" + arg).setPermission(perms[0]);
}
for (String str : plugin.getCommand("vote" + arg).getAliases()) {
commands.put(str, cmdHandle);
@@ -1266,50 +1444,43 @@ public class CommandLoader {
plugin.devDebug("Failed to load command and tab completer for /vote" + arg);
}
}
} else {
try {
String[] perms = cmdHandle.getPerm().split(Pattern.quote("|"));
if (perms.length > 1) {
// has another perm
plugin.devDebug("Adding child perm " + perms[0] + " to " + perms[1]);
Permission p = Bukkit.getPluginManager().getPermission(perms[1]);
p.getChildren().put(perms[0], true);
p.recalculatePermissibles();
}
} catch (Exception e) {
plugin.debug("Failed to set permission for /vote");
}
}
}
for (CommandHandler cmdHandle : plugin.getAdminVoteCommand()) {
if (cmdHandle.getArgs().length > 0) {
int argLength = cmdHandle.getArgs().length;
String arg0 = "";
if (argLength > 0) {
arg0 = cmdHandle.getArgs()[0];
}
String[] perms = cmdHandle.getPerm().split(Pattern.quote("|"));
try {
if (perms.length > 1) {
// has another perm
plugin.devDebug("Adding child perm " + perms[0] + " to " + perms[1] + " from /adminvote" + arg0);
Permission p = Bukkit.getPluginManager().getPermission(perms[1]);
p.getChildren().put(perms[0], true);
p.recalculatePermissibles();
}
} catch (Exception e) {
plugin.debug("Failed to set permission for /adminvote" + arg0);
}
if (argLength > 0) {
String[] args = cmdHandle.getArgs()[0].split("&");
for (String arg : args) {
commands.put("adminvote" + arg, cmdHandle);
try {
String[] perms = cmdHandle.getPerm().split(Pattern.quote("|"));
if (perms.length > 1) {
// has another perm
plugin.devDebug("Adding child perm " + perms[0] + " to " + perms[1]);
Permission p = Bukkit.getPluginManager().getPermission(perms[1]);
p.getChildren().put(perms[0], true);
p.recalculatePermissibles();
}
} catch (Exception e) {
plugin.debug("Failed to set permission for /adminvote" + arg);
}
try {
plugin.getCommand("adminvote" + arg).setExecutor(new CommandAliases(cmdHandle, true));
plugin.getCommand("adminvote" + arg)
.setTabCompleter(new AliasesTabCompleter().setCMDHandle(cmdHandle, true));
plugin.getCommand("adminvote" + arg)
.setPermission(cmdHandle.getPerm().split(Pattern.quote("|"))[0]);
String currentPerm = plugin.getCommand("adminvote" + arg).getPermission();
if (currentPerm == null || currentPerm.length() > perms[0].length()) {
plugin.getCommand("adminvote" + arg).setPermission(perms[0]);
}
for (String str : plugin.getCommand("adminvote" + arg).getAliases()) {
commands.put(str, cmdHandle);
@@ -1321,20 +1492,6 @@ public class CommandLoader {
}
}
} else {
try {
String[] perms = cmdHandle.getPerm().split(Pattern.quote("|"));
if (perms.length > 1) {
// has another perm
plugin.devDebug("Adding child perm " + perms[0] + " to " + perms[1]);
Permission p = Bukkit.getPluginManager().getPermission(perms[1]);
p.getChildren().put(perms[0], true);
p.recalculatePermissibles();
}
} catch (Exception e) {
plugin.debug("Failed to set permission for /vote");
}
}
}
}
@@ -1372,7 +1529,7 @@ public class CommandLoader {
@Override
public void onInput(Player player, String value) {
PlayerVoteEvent voteEvent = new PlayerVoteEvent(
plugin.getVoteSite(value),
plugin.getVoteSite(value, true),
UserGUI.getInstance().getCurrentPlayer(player),
plugin.getVoteSiteServiceSite(value), false);
plugin.getServer().getPluginManager().callEvent(voteEvent);
@@ -1629,8 +1786,7 @@ public class CommandLoader {
placeholders.put("limit", "" + limit);
if (user.removePoints(points)) {
RewardHandler.getInstance().giveReward(user,
plugin.getConfigFile().getData(),
RewardHandler.getInstance().giveReward(user, plugin.getGui().getData(),
plugin.getGui().getChestShopIdentifierRewardsPath(identifier),
new RewardOptions().setPlaceholders(placeholders));
@@ -1658,16 +1814,6 @@ public class CommandLoader {
});
}
plugin.getVoteCommand().add(new CommandHandler(new String[] { "URL" },
"VotingPlugin.Commands.Vote.URL|" + playerPerm, "Open VoteURL GUI", false) {
@Override
public void execute(CommandSender sender, String[] args) {
new VoteURL(plugin, sender, UserManager.getInstance().getVotingPluginUser((Player) sender), true)
.open();
}
});
plugin.getVoteCommand().add(new CommandHandler(new String[] { "URL", "(SiteName)" },
"VotingPlugin.Commands.Vote.URL.VoteSite", "Open VoteURL GUI for VoteSite", false) {
@@ -1678,12 +1824,23 @@ public class CommandLoader {
}
});
plugin.getVoteCommand().add(new CommandHandler(new String[] { "URL" },
"VotingPlugin.Commands.Vote.URL|" + playerPerm, "Open VoteURL GUI", false) {
@Override
public void execute(CommandSender sender, String[] args) {
new VoteURL(plugin, sender, UserManager.getInstance().getVotingPluginUser((Player) sender), true)
.open();
}
});
plugin.getVoteCommand().add(new CommandHandler(new String[] { "Last", "(player)" },
"VotingPlugin.Commands.Vote.Last.Other|" + modPerm, "See other players last votes") {
@Override
public void execute(CommandSender sender, String[] args) {
if (com.bencodez.advancedcore.api.user.UserManager.getInstance().userExist(args[1])) {
if (plugin.getUserManager().userExist(args[1])) {
new VoteLast(plugin, sender, UserManager.getInstance().getVotingPluginUser(args[1])).open();
} else {
sendMessage(sender, StringParser.getInstance()
@@ -1725,7 +1882,7 @@ public class CommandLoader {
@Override
public void execute(CommandSender sender, String[] args) {
if (com.bencodez.advancedcore.api.user.UserManager.getInstance().userExist(args[1])) {
if (plugin.getUserManager().userExist(args[1])) {
new VoteNext(plugin, sender, UserManager.getInstance().getVotingPluginUser(args[1])).open();
} else {
sendMessage(sender, StringParser.getInstance()
@@ -1739,7 +1896,7 @@ public class CommandLoader {
@Override
public void execute(CommandSender sender, String[] args) {
if (com.bencodez.advancedcore.api.user.UserManager.getInstance().userExist(args[1])) {
if (plugin.getUserManager().userExist(args[1])) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(args[1]);
String msg = plugin.getConfigFile().getFormatCommandVotePoints()
.replace("%Player%", user.getPlayerName()).replace("%Points%", "" + user.getPoints());
@@ -1777,21 +1934,12 @@ public class CommandLoader {
}
});
plugin.getVoteCommand().add(new CommandHandler(new String[] { "GUI" },
"VotingPlugin.Commands.Vote.GUI|" + playerPerm, "Open VoteGUI", false) {
@Override
public void execute(CommandSender sender, String[] args) {
new VoteGUI(plugin, sender, UserManager.getInstance().getVotingPluginUser((Player) sender)).open();
}
});
plugin.getVoteCommand().add(new CommandHandler(new String[] { "GUI", "(player)" },
"VotingPlugin.Commands.Vote.GUI.Other|" + modPerm, "Open VoteGUI", false) {
@Override
public void execute(CommandSender sender, String[] args) {
if (com.bencodez.advancedcore.api.user.UserManager.getInstance().userExist(args[1])) {
if (plugin.getUserManager().userExist(args[1])) {
new VoteGUI(plugin, sender, UserManager.getInstance().getVotingPluginUser(args[1])).open();
} else {
sendMessage(sender, StringParser.getInstance()
@@ -1801,6 +1949,15 @@ public class CommandLoader {
}
});
plugin.getVoteCommand().add(new CommandHandler(new String[] { "GUI" },
"VotingPlugin.Commands.Vote.GUI|" + playerPerm, "Open VoteGUI", false) {
@Override
public void execute(CommandSender sender, String[] args) {
new VoteGUI(plugin, sender, UserManager.getInstance().getVotingPluginUser((Player) sender)).open();
}
});
if (plugin.getGui().isLastMonthGUI()) {
plugin.getVoteCommand()
.add(new CommandHandler(new String[] { "LastMonthTop" },
@@ -1908,7 +2065,8 @@ public class CommandLoader {
int all = 0;
for (String uuid : uuids) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(UUID.fromString(uuid));
user.dontCache();
daily += user.getTotal(TopVoter.Daily);
weekly += user.getTotal(TopVoter.Weekly);
month += user.getTotal(TopVoter.Monthly);
@@ -1934,7 +2092,7 @@ public class CommandLoader {
@Override
public void execute(CommandSender sender, String[] args) {
if (com.bencodez.advancedcore.api.user.UserManager.getInstance().userExist(args[1])) {
if (plugin.getUserManager().userExist(args[1])) {
new VoteTotal(plugin, sender, UserManager.getInstance().getVotingPluginUser(args[1])).open();
} else {
sendMessage(sender, StringParser.getInstance()
@@ -1967,7 +2125,7 @@ public class CommandLoader {
@Override
public void execute(CommandSender sender, String[] args) {
if (com.bencodez.advancedcore.api.user.UserManager.getInstance().userExist(args[1])) {
if (plugin.getUserManager().userExist(args[1])) {
new VoteBest(plugin, sender, UserManager.getInstance().getVotingPluginUser(args[1])).open();
} else {
sendMessage(sender, StringParser.getInstance()
@@ -1990,7 +2148,7 @@ public class CommandLoader {
@Override
public void execute(CommandSender sender, String[] args) {
if (com.bencodez.advancedcore.api.user.UserManager.getInstance().userExist(args[1])) {
if (plugin.getUserManager().userExist(args[1])) {
new VoteStreak(plugin, sender, UserManager.getInstance().getVotingPluginUser(args[1])).open();
} else {
sendMessage(sender, StringParser.getInstance()
@@ -2007,21 +2165,28 @@ public class CommandLoader {
public void execute(CommandSender sender, String[] args) {
if (plugin.getConfigFile().isAllowVotePointTransfers()) {
VotingPluginUser cPlayer = UserManager.getInstance().getVotingPluginUser((Player) sender);
cPlayer.cache();
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(args[1]);
int pointsToGive = Integer.parseInt(args[2]);
if (pointsToGive > 0) {
if (cPlayer.getPoints() >= pointsToGive) {
user.addPoints(pointsToGive);
cPlayer.removePoints(pointsToGive);
sendMessage(sender, "&c" + pointsToGive + " points given to " + user.getPlayerName());
user.sendMessage(
"&cYou received " + pointsToGive + " points from " + cPlayer.getPlayerName());
if (plugin.getUserManager().userExist(args[1])) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(args[1]);
user.dontCache();
int pointsToGive = Integer.parseInt(args[2]);
if (pointsToGive > 0) {
if (cPlayer.getPoints() >= pointsToGive) {
user.addPoints(pointsToGive);
cPlayer.removePoints(pointsToGive);
sendMessage(sender,
"&c" + pointsToGive + " points given to " + user.getPlayerName());
user.sendMessage("&cYou received " + pointsToGive + " points from "
+ cPlayer.getPlayerName());
} else {
sendMessage(sender, "&cNot enough points");
}
} else {
sendMessage(sender, "&cNot enough points");
sendMessage(sender, "&cNumber of points needs to be greater than 0");
}
} else {
sendMessage(sender, "&cNumber of points needs to be greater than 0");
sendMessage(sender, "&c" + args[1] + " has not joined the server");
}
}
}
@@ -8,6 +8,7 @@ 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;
@@ -17,13 +18,21 @@ import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueBo
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.AdminVoteBungeeSettings;
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;
@@ -65,7 +74,90 @@ public class AdminGUI {
}
});
buttons.add(new BInventoryButton("&cReload Plugin", new String[] {}, new ItemStack(Material.STONE, 1)) {
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 FirstVoteToday reward")) {
@Override
public void onClick(ClickEvent clickEvent) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(),
RewardHandler.getInstance().getDirectlyDefined("FirstVoteToday"));
}
});
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(new ItemBuilder("GRASS_BLOCK").setName("&cEdit BungeeSettings.yml")) {
@Override
public void onClick(ClickEvent clickEvent) {
new AdminVoteBungeeSettings(plugin, clickEvent.getPlayer()).open();
}
});
buttons.add(new BInventoryButton("&cReload Plugin", new String[] {}, new ItemStack(Material.BUCKET, 1)) {
@Override
public void onClick(ClickEvent event) {
@@ -97,6 +189,7 @@ public class AdminGUI {
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)) {
@@ -201,6 +294,17 @@ public class AdminGUI {
}
}));
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
@@ -246,6 +350,15 @@ public class AdminGUI {
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,138 @@
package com.bencodez.votingplugin.commands.gui.admin;
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.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.EditGUIValueString;
import com.bencodez.votingplugin.VotingPluginMain;
public class AdminVoteBungeeSettings extends GUIHandler {
private VotingPluginMain plugin;
public AdminVoteBungeeSettings(VotingPluginMain plugin, CommandSender player) {
super(plugin, 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) {
EditGUI inv = new EditGUI("Edit BungeeSettings");
inv.requirePermission("VotingPlugin.Commands.AdminVote.Edit.BungeeSettings");
inv.addButton(new EditGUIButton(
new EditGUIValueBoolean("UseBungeecord", plugin.getBungeeSettings().isUseBungeecoord()) {
@Override
public void setValue(Player player, boolean value) {
setPathData(getKey(), value);
}
}));
inv.addButton(
new EditGUIButton(new EditGUIValueString("BungeeMethod", plugin.getBungeeSettings().getBungeeMethod()) {
@Override
public void setValue(Player player, String value) {
setPathData(getKey(), value);
}
}).addOptions("PLUGINMESSAGING", "SOCKETS", "MYSQL"));
inv.addButton(
new EditGUIButton(new EditGUIValueBoolean("BungeeDebug", plugin.getBungeeSettings().isBungeeDebug()) {
@Override
public void setValue(Player player, boolean value) {
setPathData(getKey(), value);
}
}));
inv.addButton(new EditGUIButton(
new EditGUIValueBoolean("BungeeBroadcast", plugin.getBungeeSettings().isBungeeBroadcast()) {
@Override
public void setValue(Player player, boolean value) {
setPathData(getKey(), value);
}
}.addLore("Triggers a broadcast for the entire network, most cases it is best for this to be false")));
inv.addButton(new EditGUIButton(
new EditGUIValueBoolean("BungeeBroadcastAlways", plugin.getBungeeSettings().isBungeeBroadcastAlways()) {
@Override
public void setValue(Player player, boolean value) {
setPathData(getKey(), value);
}
}.addLore("Whether or not to broadcast on cached votes").addLore("PLUGINMESSAGING ONLY")));
inv.addButton(new EditGUIButton(
new EditGUIValueBoolean("PerServerRewards", plugin.getBungeeSettings().isPerServerRewards()) {
@Override
public void setValue(Player player, boolean value) {
setPathData(getKey(), value);
}
}));
inv.addButton(new EditGUIButton(
new EditGUIValueBoolean("PerServerPoints", plugin.getBungeeSettings().isPerServerPoints()) {
@Override
public void setValue(Player player, boolean value) {
setPathData(getKey(), value);
}
}));
inv.addButton(new EditGUIButton(
new EditGUIValueBoolean("TriggerVotifierEvent", plugin.getBungeeSettings().isTriggerVotifierEvent()) {
@Override
public void setValue(Player player, boolean value) {
setPathData(getKey(), value);
}
}));
inv.addButton(new EditGUIButton(new EditGUIValueString("Server", plugin.getBungeeSettings().getServer()) {
@Override
public void setValue(Player player, String value) {
setPathData(getKey(), value);
}
}.addLore("Server name as stated in proxy")));
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.CHEST);
}
private void setPathData(String path, Object value) {
plugin.getBungeeSettings().getData().set(path, value);
plugin.getBungeeSettings().saveData();
plugin.reload();
}
}
@@ -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(plugin, 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) {
}
@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);
}
public abstract void onConfirm(Player p);
public abstract void onDeny(Player p);
@Override
public void open() {
open(GUIMethod.CHEST);
}
}
@@ -21,7 +21,7 @@ public class AdminVoteHelp extends GUIHandler {
private VotingPluginMain plugin;
public AdminVoteHelp(VotingPluginMain plugin, CommandSender player, int page) {
super(player);
super(plugin, player);
this.plugin = plugin;
this.page = page;
}
@@ -67,9 +67,7 @@ public class AdminVoteHelp extends GUIHandler {
boolean requirePerms = plugin.getConfigFile().getFormatCommandsVoteHelpRequirePermission();
for (CommandHandler cmdHandle : plugin.getAdminVoteCommand()) {
if (requirePerms && sender.hasPermission(cmdHandle.getPerm())) {
unsorted.put(cmdHandle.getHelpLineCommand("/adminvote"), cmdHandle.getHelpLine("/adminvote"));
} else {
if (!requirePerms || cmdHandle.hasPerm(sender)) {
unsorted.put(cmdHandle.getHelpLineCommand("/adminvote"), cmdHandle.getHelpLine("/adminvote"));
}
}
@@ -22,13 +22,13 @@ public class AdminVotePerms extends GUIHandler {
private VotingPluginMain plugin;
public AdminVotePerms(VotingPluginMain plugin, CommandSender player, int page) {
super(player);
super(plugin, player);
this.plugin = plugin;
this.page = page;
}
public AdminVotePerms(VotingPluginMain plugin, CommandSender player, int page, String playerName) {
super(player);
super(plugin, player);
this.plugin = plugin;
this.page = page;
this.playerName = playerName;
@@ -19,11 +19,10 @@ import xyz.upperlevel.spigot.book.BookUtil;
public class AdminVotePlaceholders extends GUIHandler {
@SuppressWarnings("unused")
private VotingPluginMain plugin;
public AdminVotePlaceholders(VotingPluginMain plugin, CommandSender player) {
super(player);
super(plugin, player);
this.plugin = plugin;
}
@@ -43,9 +42,9 @@ public class AdminVotePlaceholders extends GUIHandler {
identifier += "#";
}
if (placeholder.hasDescription()) {
msg = "%VotingPlugin_" + identifier + "% - " + placeholder.getDescription();
msg = "VotingPlugin_" + identifier + " - " + placeholder.getDescription();
} else {
msg = "%VotingPlugin_" + identifier + "%";
msg = "VotingPlugin_" + identifier + "";
}
Layout layout = new Layout(new ArrayList<String>(Arrays.asList("[Json]")));
@@ -61,9 +60,9 @@ public class AdminVotePlaceholders extends GUIHandler {
identifier += "#";
}
if (placeholder.hasDescription()) {
msg = "%VotingPlugin_" + identifier + "% - " + placeholder.getDescription();
msg = "VotingPlugin_" + identifier + " - " + placeholder.getDescription();
} else {
msg = "%VotingPlugin_" + identifier + "%";
msg = "VotingPlugin_" + identifier + "";
}
Layout layout = new Layout(new ArrayList<String>(Arrays.asList("[Json]")));
@@ -87,9 +86,9 @@ public class AdminVotePlaceholders extends GUIHandler {
identifier += "#";
}
if (placeholder.hasDescription()) {
msg.add("%VotingPlugin_" + identifier + "% - " + placeholder.getDescription());
msg.add("VotingPlugin_" + identifier + " - " + placeholder.getDescription());
} else {
msg.add("%VotingPlugin_" + identifier + "%");
msg.add("VotingPlugin_" + identifier + "");
}
}
@@ -99,9 +98,9 @@ public class AdminVotePlaceholders extends GUIHandler {
identifier += "#";
}
if (placeholder.hasDescription()) {
msg.add("%VotingPlugin_" + identifier + "% - " + placeholder.getDescription());
msg.add("VotingPlugin_" + identifier + " - " + placeholder.getDescription());
} else {
msg.add("%VotingPlugin_" + identifier + "%");
msg.add("VotingPlugin_" + identifier + "");
}
}
@@ -20,12 +20,11 @@ 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);
super(plugin, player);
this.plugin = plugin;
this.user = user;
}
@@ -82,7 +81,7 @@ public class AdminVotePlaceholdersPlayer extends GUIHandler {
if (identifier.endsWith("_")) {
identifier += "1";
}
msg.add("%VotingPlugin_" + identifier + "% = "
msg.add("VotingPlugin_" + identifier + " = "
+ placeholder.placeholderRequest(user.getOfflinePlayer(), placeholderUser, identifier));
}
@@ -92,7 +91,7 @@ public class AdminVotePlaceholdersPlayer extends GUIHandler {
identifier += "1";
}
msg.add("%VotingPlugin_" + identifier + "% = "
msg.add("VotingPlugin_" + identifier + " = "
+ placeholder.placeholderRequest(user.getOfflinePlayer(), placeholderUser, identifier));
}
sendMessage(msg);
@@ -0,0 +1,235 @@
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(plugin, 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) {
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(
"GiveOnlinePlayersOnly", plugin.getSpecialRewardsConfig().isVotePartyGiveOnlinePlayersOnly()) {
@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);
}
private void setPathData(String path, Object value) {
plugin.getSpecialRewardsConfig().getData().set("VoteParty." + path, value);
plugin.getSpecialRewardsConfig().saveData();
plugin.reload();
}
}
@@ -0,0 +1,80 @@
package com.bencodez.votingplugin.commands.gui.admin;
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.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.inventory.editgui.EditGUI;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.events.PlayerVoteEvent;
import com.bencodez.votingplugin.objects.VoteSite;
public class AdminVoteVotePlayer extends GUIHandler {
private String playerName;
private VotingPluginMain plugin;
public AdminVoteVotePlayer(VotingPluginMain plugin, CommandSender player, String playerName) {
super(plugin, player);
this.plugin = plugin;
this.playerName = playerName;
}
@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) {
EditGUI inv = new EditGUI("Trigger vote for " + playerName);
inv.requirePermission("VotingPlugin.Commands.AdminVote.Vote|VotingPlugin.Admin");
for (VoteSite site : plugin.getVoteSites()) {
inv.addButton(new BInventoryButton(site.getItem().setName(site.getKey())) {
@Override
public void onClick(ClickEvent clickEvent) {
VoteSite site = (VoteSite) getData("site");
PlayerVoteEvent voteEvent = new PlayerVoteEvent(site, playerName, site.getServiceSite(), false);
sendMessage(clickEvent.getPlayer(), "&cTriggering vote...");
if (voteEvent.getVoteSite() != null) {
if (!voteEvent.getVoteSite().isVaidServiceSite()) {
sendMessage(clickEvent.getPlayer(),
"&cPossible issue with service site, has the server gotten the vote from "
+ voteEvent.getServiceSite() + "?");
}
}
plugin.getServer().getPluginManager().callEvent(voteEvent);
if (plugin.isYmlError()) {
sendMessage(clickEvent.getPlayer(),
"&3Detected yml error, please check server log for details");
}
}
}.addData("site", site));
}
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.CHEST);
}
}
@@ -0,0 +1,110 @@
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(plugin, 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,78 @@
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(plugin, 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 onConfirm(Player p) {
plugin.getSpecialRewardsConfig().removeCumulative(votes);
p.sendMessage("Removed cumulative " + votes);
plugin.reload();
}
@Override
public void onDeny(Player p) {
new AdminVoteCumulative(plugin, p);
}
}.open();
;
}
});
}
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.CHEST);
}
}
@@ -0,0 +1,78 @@
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(plugin, 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 onConfirm(Player p) {
plugin.getSpecialRewardsConfig().removeMilestone(votes);
p.sendMessage("Removed milestone " + votes);
plugin.reload();
}
@Override
public void onDeny(Player p) {
new AdminVoteMilestones(plugin, p);
}
}.open();
;
}
});
}
inv.openInventory(player);
}
@Override
public void open() {
open(GUIMethod.CHEST);
}
}
@@ -0,0 +1,110 @@
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(plugin, 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(plugin, 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.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.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 String identifier;
private VotingPluginMain plugin;
public AdminVoteVoteShopItem(VotingPluginMain plugin, CommandSender player, String identifier) {
super(plugin, 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) {
}
@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);
}
private void setPathData(String path, Object value) {
plugin.getGui().getData().set("CHEST.Shop." + identifier + "." + path, value);
plugin.getGui().saveData();
plugin.reload();
}
}
@@ -0,0 +1,80 @@
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(plugin, 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 onConfirm(Player p) {
plugin.getGui().removeShop(identifier);
p.sendMessage("Removed " + identifier);
plugin.reload();
}
@Override
public void onDeny(Player p) {
new AdminVoteVoteShop(plugin, p).open();
}
}.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(plugin, 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);
}
}
@@ -18,12 +18,11 @@ 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);
super(plugin, player);
this.plugin = plugin;
this.user = user;
}
@@ -11,8 +11,9 @@ 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.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;
@@ -24,7 +25,7 @@ public class VoteGUI extends GUIHandler {
private VotingPluginUser user;
public VoteGUI(VotingPluginMain plugin, CommandSender player, VotingPluginUser user) {
super(player);
super(plugin, player);
this.plugin = plugin;
this.user = user;
}
@@ -120,16 +121,7 @@ public class VoteGUI extends GUIHandler {
@Override
public void onChest(Player player) {
if (this.user == null) {
user = UserManager.getInstance().getVotingPluginUser((Player) player);
}
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(
StringParser.getInstance().colorize(VotingPluginMain.plugin.getOptions().getFormatNoPerms()));
return;
user = UserManager.getInstance().getVotingPluginUser(player);
}
BInventory inv = new BInventory(plugin.getGui().getChestVoteGUIName());
if (!plugin.getConfigFile().isAlwaysCloseInventory()) {
@@ -181,6 +173,13 @@ public class VoteGUI extends GUIHandler {
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
@@ -13,6 +13,7 @@ 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.ChatColor;
import net.md_5.bungee.api.chat.TextComponent;
public class VoteHelp extends GUIHandler {
@@ -21,7 +22,7 @@ public class VoteHelp extends GUIHandler {
private VotingPluginMain plugin;
public VoteHelp(VotingPluginMain plugin, CommandSender player, int page) {
super(player);
super(plugin, player);
this.plugin = plugin;
this.page = page;
}
@@ -37,12 +38,19 @@ public class VoteHelp extends GUIHandler {
boolean requirePerms = plugin.getConfigFile().getFormatCommandsVoteHelpRequirePermission();
String colorStr = plugin.getConfigFile().getFormatCommandsVoteHelpHoverColor();
ChatColor hoverColor = null;
try {
hoverColor = ChatColor.of(colorStr);
} catch (Exception e) {
plugin.getLogger().warning("Failed to get color for hover help message");
e.printStackTrace();
hoverColor = ChatColor.AQUA;
}
for (CommandHandler cmdHandle : plugin.getVoteCommand()) {
if (requirePerms && sender.hasPermission(cmdHandle.getPerm())) {
unsorted.put(cmdHandle.getHelpLineCommand("/vote"),
cmdHandle.getHelpLine("/vote", plugin.getConfigFile().getFormatCommandsVoteHelpLine()));
} else {
unsorted.put(cmdHandle.getHelpLineCommand("/vote"), cmdHandle.getHelpLine("/vote"));
if (!requirePerms || cmdHandle.hasPerm(sender)) {
unsorted.put(cmdHandle.getHelpLineCommand("/vote"), cmdHandle.getHelpLine("/vote",
plugin.getConfigFile().getFormatCommandsVoteHelpLine(), hoverColor));
}
}
ArrayList<String> unsortedList = new ArrayList<String>();
@@ -23,7 +23,7 @@ public class VoteLast extends GUIHandler {
private VotingPluginUser user;
public VoteLast(VotingPluginMain plugin, CommandSender player, VotingPluginUser user) {
super(player);
super(plugin, player);
this.plugin = plugin;
this.user = user;
}
@@ -38,7 +38,9 @@ public class VoteLast extends GUIHandler {
"%player%", playerName));
for (VoteSite voteSite : plugin.getVoteSites()) {
msg.add(user.voteCommandLastLine(voteSite));
if (!voteSite.isHidden()) {
msg.add(user.voteCommandLastLine(voteSite));
}
}
return ArrayUtils.getInstance().colorize(msg);
@@ -59,20 +61,23 @@ public class VoteLast extends GUIHandler {
BInventory inv = new BInventory(plugin.getGui().getChestVoteLastName());
inv.addPlaceholder("player", user.getPlayerName());
for (VoteSite site : plugin.getVoteSites()) {
inv.addButton(inv.getNextSlot(), new UpdatingBInventoryButton(site.getItem().setName(site.getDisplayName())
.setLore(user.voteCommandLastLine(site)).setAmountNone(1), 1000, 1000) {
if (!site.isHidden()) {
inv.addButton(inv.getNextSlot(),
new UpdatingBInventoryButton(site.getItem().setName(site.getDisplayName())
.setLore(user.voteCommandLastGUILine(site)).setAmountNone(1), 1000, 1000) {
@Override
public void onClick(ClickEvent clickEvent) {
@Override
public void onClick(ClickEvent clickEvent) {
}
}
@Override
public ItemBuilder onUpdate(Player p) {
return site.getItem().setName(site.getDisplayName()).setLore(user.voteCommandLastLine(site))
.setAmountNone(1);
}
});
@Override
public ItemBuilder onUpdate(Player p) {
return site.getItem().setName(site.getDisplayName())
.setLore(user.voteCommandLastGUILine(site)).setAmountNone(1);
}
});
}
}
if (plugin.getGui().getChestVoteLastBackButton()) {
@@ -27,7 +27,7 @@ public class VoteNext extends GUIHandler {
private VotingPluginUser user;
public VoteNext(VotingPluginMain plugin, CommandSender player, VotingPluginUser user) {
super(player);
super(plugin, player);
this.plugin = plugin;
this.user = user;
}
@@ -42,15 +42,16 @@ public class VoteNext extends GUIHandler {
.replaceIgnoreCase(plugin.getConfigFile().getFormatCommandsVoteNextTitle(), "%player%", playerName)));
for (VoteSite voteSite : plugin.getVoteSites()) {
if (!voteSite.isHidden()) {
String msgLine = plugin.getConfigFile().getFormatCommandsVoteNextLayout();
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));
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;
}
@@ -61,12 +62,14 @@ public class VoteNext extends GUIHandler {
// 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);
if (!site.isHidden()) {
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();
@@ -83,20 +86,24 @@ public class VoteNext extends GUIHandler {
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) {
if (!site.isHidden()) {
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 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());
}
});
@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()) {
@@ -25,7 +25,7 @@ public class VoteShop extends GUIHandler {
private VotingPluginUser user;
public VoteShop(VotingPluginMain plugin, CommandSender player, VotingPluginUser user) {
super(player);
super(plugin, player);
this.plugin = plugin;
this.user = user;
}
@@ -85,10 +85,8 @@ public class VoteShop extends GUIHandler {
Player player = event.getWhoClicked();
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(player);
if (plugin.getConfigFile().isClearCacheOnVoteShopPurchase()
|| plugin.getBungeeSettings().isUseBungeecoord()) {
user.clearCache();
}
user.clearCache();
String identifier = (String) getData("identifier");
int limit = (int) getData("Limit");
int points = plugin.getGui().getChestShopIdentifierCost(identifier);
@@ -113,13 +111,16 @@ public class VoteShop extends GUIHandler {
placeholders.put("points", "" + points);
placeholders.put("limit", "" + limit);
if (user.removePoints(points)) {
plugin.getLogger().info("VoteShop: " + user.getPlayerName() + "/"
+ user.getUUID() + " bought " + identifier + " for " + 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));
plugin.getGui().getCHESTVoteShopPurchase(identifier),
placeholders));
if (limit > 0) {
user.setVoteShopIdentifierLimit(identifier,
user.getVoteShopIdentifierLimit(identifier) + 1);
@@ -26,7 +26,7 @@ public class VoteShopConfirm extends GUIHandler {
private VotingPluginUser user;
public VoteShopConfirm(VotingPluginMain plugin, CommandSender player, VotingPluginUser user, String identifier) {
super(player);
super(plugin, player);
this.plugin = plugin;
this.user = user;
this.identifier = identifier;
@@ -49,10 +49,12 @@ public class VoteShopConfirm extends GUIHandler {
public void onChest(Player player) {
PlayerUtils.getInstance().setPlayerMeta(player, "ident", identifier);
BInventory inv = new BInventory(plugin.getGui().getChestShopConfirmPurchaseTitle());
inv.dontClose();
inv.addButton(new BInventoryButton(new ItemBuilder(plugin.getGui().getChestShopConfirmPurchaseYesItem())) {
@Override
public void onClick(ClickEvent event) {
user.clearCache();
int points = plugin.getGui().getChestShopIdentifierCost(identifier);
int limit = plugin.getGui().getChestShopIdentifierLimit(identifier);
HashMap<String, String> placeholders = new HashMap<String, String>();
@@ -60,6 +62,8 @@ public class VoteShopConfirm extends GUIHandler {
placeholders.put("points", "" + points);
placeholders.put("limit", "" + limit);
if (user.removePoints(points)) {
plugin.getLogger().info("VoteShop: " + user.getPlayerName() + "/" + user.getUUID() + " bought "
+ identifier + " for " + points);
RewardHandler.getInstance().giveReward(user, plugin.getGui().getData(),
plugin.getGui().getChestShopIdentifierRewardsPath(identifier),
@@ -77,7 +81,7 @@ public class VoteShopConfirm extends GUIHandler {
if (plugin.getGui().getChestVoteShopCloseGUI(identifier)) {
event.getButton().getInv().closeInv(player, null);
} else {
new VoteShop(plugin, event.getPlayer(), user);
new VoteShop(plugin, event.getPlayer(), user).open();
}
}
@@ -23,7 +23,7 @@ public class VoteStreak extends GUIHandler {
private VotingPluginUser user;
public VoteStreak(VotingPluginMain plugin, CommandSender player, VotingPluginUser user) {
super(player);
super(plugin, player);
this.plugin = plugin;
this.user = user;
}
@@ -5,6 +5,7 @@ import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.UUID;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@@ -17,10 +18,10 @@ 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.topvoter.TopVoterPlayer;
import com.bencodez.votingplugin.user.UserManager;
import com.bencodez.votingplugin.user.VotingPluginUser;
@@ -31,7 +32,7 @@ public class VoteToday extends GUIHandler {
private VotingPluginUser user;
public VoteToday(VotingPluginMain plugin, CommandSender player, VotingPluginUser user, int page) {
super(player);
super(plugin, player);
this.plugin = plugin;
this.user = user;
this.page = page;
@@ -51,15 +52,21 @@ public class VoteToday extends GUIHandler {
maxPage++;
}
msg.add("&cToday's Votes " + page + "/" + maxPage);
msg.add("&cPlayerName : VoteSite : Time");
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(msg);
return ArrayUtils.getInstance().colorize(ArrayUtils.getInstance().replacePlaceHolder(msg, placeholders));
}
@Override
@@ -78,7 +85,7 @@ public class VoteToday extends GUIHandler {
if (!plugin.getConfigFile().isAlwaysCloseInventory()) {
inv.dontClose();
}
for (VotingPluginUser user : plugin.getVoteToday().keySet()) {
for (TopVoterPlayer user : plugin.getVoteToday().keySet()) {
for (VoteSite voteSite : plugin.getVoteToday().get(user).keySet()) {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(plugin.getConfigFile().getFormatTimeFormat());
@@ -97,12 +104,12 @@ public class VoteToday extends GUIHandler {
item.setName(StringParser.getInstance().replacePlaceHolder(plugin.getGui().getChestVoteTodayIconTitle(),
"player", user.getPlayerName()));
item.setLore(msg);
final String uuid = user.getUUID();
final UUID uuid = user.getUuid();
inv.addButton(inv.getNextSlot(), new BInventoryButton(item) {
@Override
public void onClick(ClickEvent clickEvent) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(uuid);
new VoteGUI(plugin, player, user)
.open(GUIMethod.valueOf(plugin.getGui().getGuiMethodGUI().toUpperCase()));
}
@@ -123,7 +130,7 @@ public class VoteToday extends GUIHandler {
public String[] voteToday() {
ArrayList<String> msg = new ArrayList<String>();
for (VotingPluginUser user : plugin.getVoteToday().keySet()) {
for (TopVoterPlayer user : plugin.getVoteToday().keySet()) {
for (VoteSite voteSite : plugin.getVoteToday().get(user).keySet()) {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(plugin.getConfigFile().getFormatTimeFormat());
@@ -144,7 +151,7 @@ public class VoteToday extends GUIHandler {
public String[] voteTodayGUI() {
ArrayList<String> msg = new ArrayList<String>();
for (VotingPluginUser user : plugin.getVoteToday().keySet()) {
for (TopVoterPlayer user : plugin.getVoteToday().keySet()) {
LocalDateTime mostRecent = null;
VoteSite mostRecentSite = null;
@@ -19,6 +19,7 @@ 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.topvoter.TopVoterPlayer;
import com.bencodez.votingplugin.user.VotingPluginUser;
public class VoteTopVoter extends GUIHandler {
@@ -29,7 +30,7 @@ public class VoteTopVoter extends GUIHandler {
private VotingPluginUser user;
public VoteTopVoter(VotingPluginMain plugin, CommandSender player, VotingPluginUser user, TopVoter top, int page) {
super(player);
super(plugin, player);
this.plugin = plugin;
this.user = user;
this.top = top;
@@ -69,11 +70,11 @@ public class VoteTopVoter extends GUIHandler {
if (top == null) {
top = TopVoter.getDefault();
}
Set<Entry<VotingPluginUser, Integer>> users = null;
Set<Entry<TopVoterPlayer, Integer>> users = null;
String topVoter = top.getName();
@SuppressWarnings("unchecked")
LinkedHashMap<VotingPluginUser, Integer> topVotes = (LinkedHashMap<VotingPluginUser, Integer>) plugin
LinkedHashMap<TopVoterPlayer, Integer> topVotes = (LinkedHashMap<TopVoterPlayer, Integer>) plugin
.getTopVoter(top).clone();
users = topVotes.entrySet();
@@ -84,7 +85,7 @@ public class VoteTopVoter extends GUIHandler {
}
int pos = 1;
for (Entry<VotingPluginUser, Integer> entry : users) {
for (Entry<TopVoterPlayer, Integer> entry : users) {
ItemBuilder playerItem;
if (plugin.getGui().isChestVoteTopUseSkull()) {
@@ -102,9 +103,13 @@ public class VoteTopVoter extends GUIHandler {
@Override
public void onClick(ClickEvent clickEvent) {
VotingPluginUser user = (VotingPluginUser) getData("User");
new VoteGUI(plugin, player, user)
.open(GUIMethod.valueOf(plugin.getGui().getGuiMethodGUI().toUpperCase()));
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++;
@@ -15,6 +15,7 @@ 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.topvoter.TopVoterPlayer;
import com.bencodez.votingplugin.user.VotingPluginUser;
public class VoteTopVoterLastMonth extends GUIHandler {
@@ -23,7 +24,7 @@ public class VoteTopVoterLastMonth extends GUIHandler {
private VotingPluginUser user;
public VoteTopVoterLastMonth(VotingPluginMain plugin, CommandSender player, VotingPluginUser user) {
super(player);
super(plugin, player);
this.plugin = plugin;
this.user = user;
}
@@ -44,7 +45,7 @@ public class VoteTopVoterLastMonth extends GUIHandler {
@Override
public void onChest(Player player) {
Set<Entry<VotingPluginUser, Integer>> users = null;
Set<Entry<TopVoterPlayer, Integer>> users = null;
users = plugin.getLastMonthTopVoter().entrySet();
@@ -55,7 +56,7 @@ public class VoteTopVoterLastMonth extends GUIHandler {
}
int pos = 1;
for (Entry<VotingPluginUser, Integer> entry : users) {
for (Entry<TopVoterPlayer, Integer> entry : users) {
ItemBuilder playerItem;
if (plugin.getGui().isChestVoteTopUseSkull()) {
@@ -19,12 +19,11 @@ 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);
super(plugin, player);
this.plugin = plugin;
this.user = user;
}
@@ -14,11 +14,13 @@ 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.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;
@@ -34,7 +36,7 @@ public class VoteURL extends GUIHandler {
private VotingPluginUser user;
public VoteURL(VotingPluginMain plugin, CommandSender player, VotingPluginUser user, boolean json) {
super(player);
super(plugin, player);
this.plugin = plugin;
this.user = user;
this.json = json;
@@ -59,16 +61,18 @@ public class VoteURL extends GUIHandler {
if (plugin.getConfigFile().getFormatCommandsVoteAutoInputSites()) {
int counter = 0;
for (VoteSite voteSite : plugin.getVoteSites()) {
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));
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());
}
sites.add(message.colorize().getText());
}
}
if (user != null) {
@@ -102,19 +106,26 @@ public class VoteURL extends GUIHandler {
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)));
}
builder.setName(plugin.getGui().getChestVoteURLGUISiteName().replace("%Name%", voteSite.getDisplayName()));
return builder;
}
@@ -151,12 +162,10 @@ public class VoteURL extends GUIHandler {
public void onChest(Player player) {
// normal GUI
BInventory inv = new BInventory(plugin.getGui().getChestVoteURLName());
int count = 0;
if (plugin.getGui().getChestVoteURLViewAllUrlsButtonEnabled()) {
ItemBuilder builderAll = getItemAll();
inv.addButton(count, new UpdatingBInventoryButton(builderAll, 1000, 1000) {
inv.addButton(new UpdatingBInventoryButton(builderAll, 5000, 5000) {
@Override
public void onClick(ClickEvent event) {
@@ -170,38 +179,53 @@ public class VoteURL extends GUIHandler {
return getItemAll();
}
});
count++;
}
int startSlot = plugin.getGui().getChestVoteURLAllUrlsButtonStartSlot();
for (final VoteSite voteSite : plugin.getVoteSites()) {
ItemBuilder builder = getItemVoteSite(voteSite);
if (!voteSite.isHidden()) {
ItemBuilder builder = getItemVoteSite(voteSite);
if (startSlot >= 0) {
builder.setSlot(startSlot);
startSlot++;
}
inv.addButton(count, new UpdatingBInventoryButton(builder, 1000, 1000) {
inv.addButton(new UpdatingBInventoryButton(builder, 5000, 5000) {
@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 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 ItemBuilder onUpdate(Player player) {
return getItemVoteSite(voteSite);
public void onClick(ClickEvent clickEvent) {
new RewardBuilder(plugin.getGui().getData(), "CHEST.VoteURL.ExtraItems." + str + ".Rewards")
.setGiveOffline(false).send(clickEvent.getPlayer());
;
}
});
count++;
}
if (plugin.getGui().getChestVoteURLBackButton()) {
@@ -24,7 +24,7 @@ public class VoteURLVoteSite extends GUIHandler {
private String voteSite;
public VoteURLVoteSite(VotingPluginMain plugin, CommandSender player, VotingPluginUser user, String voteSite) {
super(player);
super(plugin, player);
this.plugin = plugin;
this.user = user;
this.voteSite = voteSite;
@@ -51,7 +51,7 @@ public class VoteURLVoteSite extends GUIHandler {
player.sendMessage("Not a valid votesite");
return;
}
VoteSite site = plugin.getVoteSite(voteSite);
VoteSite site = plugin.getVoteSite(voteSite, true);
BInventory inv = new BInventory(plugin.getGui().getChestVoteURLSiteName());
inv.addPlaceholder("site", site.getDisplayName());
inv.setMeta(player, "VoteSite", site);
@@ -37,6 +37,14 @@ public class BungeeSettings extends YMLFile {
@Getter
private int bungeeServerPort = 1297;
@ConfigDataBoolean(path = "PerServerPoints")
@Getter
private boolean perServerPoints = false;
@ConfigDataBoolean(path = "PerServerRewards")
@Getter
private boolean perServerRewards = false;
@ConfigDataBoolean(path = "RemoveInvalidUsers")
@Getter
private boolean removeInvalidUsers = false;
@@ -53,14 +61,26 @@ public class BungeeSettings extends YMLFile {
@Getter
private int spigotServerPort = 1298;
@ConfigDataBoolean(path = "TriggerVotifierEvent")
@Getter
private boolean triggerVotifierEvent = false;
@ConfigDataBoolean(path = "UseBungeecord", secondPath = "UseBungeecoord")
@Getter
private boolean useBungeecoord = false;
@ConfigDataBoolean(path = "VotifierBypass")
@Getter
private boolean votifierBypass = false;
public BungeeSettings(VotingPluginMain plugin) {
super(plugin, new File(plugin.getDataFolder(), "BungeeSettings.yml"));
}
public String getServerNameStorage() {
return getServer().replace("-", "_");
}
@Override
public void loadValues() {
new AnnotationHandler().load(getData(), this);
@@ -7,6 +7,7 @@ import java.util.Set;
import org.bukkit.configuration.ConfigurationSection;
import com.bencodez.advancedcore.api.misc.ArrayUtils;
import com.bencodez.advancedcore.api.yml.YMLFile;
import com.bencodez.advancedcore.api.yml.annotation.AnnotationHandler;
import com.bencodez.advancedcore.api.yml.annotation.ConfigDataBoolean;
@@ -36,9 +37,9 @@ public class Config extends YMLFile {
@Getter
private boolean allowUnjoined = false;
@ConfigDataBoolean(path = "UseVoteGUIMainCommand")
@ConfigDataBoolean(path = "PreloadSkulls")
@Getter
private boolean useVoteGUIMainCommand = false;
private boolean preloadSkulls = false;
@ConfigDataBoolean(path = "AllowUnJoinedCheckServer")
@Getter
@@ -48,10 +49,6 @@ public class Config extends YMLFile {
@Getter
private boolean allowVotePointTransfers = false;
@ConfigDataBoolean(path = "AlterColumns")
@Getter
private boolean alterColumns = true;
@ConfigDataBoolean(path = "AlternateUUIDLookup")
@Getter
private boolean alternateUUIDLookup = false;
@@ -64,6 +61,10 @@ public class Config extends YMLFile {
@Getter
private boolean alwaysUpdate = false;
@ConfigDataBoolean(path = "AlwaysWaitForCachePlaceholders")
@Getter
private boolean alwaysWaitForCachePlaceholders = false;
@ConfigDataBoolean(path = "AutoCreateVoteSites")
@Getter
private boolean autoCreateVoteSites = true;
@@ -72,26 +73,6 @@ public class Config extends YMLFile {
@Getter
private boolean broadcastVotesEnabled = true;
@ConfigDataBoolean(path = "clearCacheOnUpdate")
@Getter
private boolean clearCacheOnUpdate = false;
@ConfigDataBoolean(path = "ClearCacheOnVote")
@Getter
private boolean clearCacheOnVote = false;
@ConfigDataBoolean(path = "ClearCacheOnVoteShopPurchase")
@Getter
private boolean clearCacheOnVoteShopPurchase = true;
@ConfigDataInt(path = "ConvertAmount")
@Getter
private int convertAmount = 250;
@ConfigDataInt(path = "ConvertDelay", defaultValue = 30000)
@Getter
private int convertDelay;
@ConfigDataBoolean(path = "CountFakeVotes")
@Getter
private boolean countFakeVotes = true;
@@ -100,10 +81,18 @@ public class Config extends YMLFile {
@Getter
private int delayBetweenUpdates = 3;
@ConfigDataInt(path = "DelayLoginEvent")
@Getter
private int delayLoginEvent = 0;
@ConfigDataBoolean(path = "DisableAdvancedTab")
@Getter
private boolean disableAdvancedTab = false;
@ConfigDataBoolean(path = "DisableCoolDownCheck")
@Getter
private boolean disableCoolDownCheck = false;
@ConfigDataListString(path = "DisabledCommands")
@Getter
private ArrayList<String> disabledCommands = new ArrayList<String>();
@@ -112,6 +101,10 @@ public class Config extends YMLFile {
@Getter
private ArrayList<String> disabledDefaultPermissions = new ArrayList<String>();
@ConfigDataBoolean(path = "DisableInteractEvent")
@Getter
private boolean disableInteractEvent = false;
@ConfigDataBoolean(path = "DisableNoServiceSiteMessage")
@Getter
private boolean disableNoServiceSiteMessage = false;
@@ -120,10 +113,26 @@ public class Config extends YMLFile {
@Getter
private boolean disableUpdateChecking = false;
@ConfigDataBoolean(path = "ExtraAllSitesCheck")
@Getter
private boolean extraAllSitesCheck = false;
@ConfigDataBoolean(path = "ExtraBackgroundUpdate")
@Getter
private boolean extraBackgroundUpdate = false;
@ConfigDataString(path = "Format.AlternateBroadcast.Broadcast")
@Getter
private String formatAlternateBroadcastBroadcast = "&6[&4Broadcast&6] &2%numberofplayers% voted in the last half hour! /vote";
@ConfigDataInt(path = "Format.AlternateBroadcast.Delay")
@Getter
private int formatAlternateBroadcastDelay = 30;
@ConfigDataBoolean(path = "Format.AlternateBroadcast.Enabled")
@Getter
private boolean formatAlternateBroadcastEnabled = false;
@ConfigDataBoolean(path = "Format.Commands.Vote.ForceLinks")
@Getter
private boolean formatCommandsVoteForceLinks = true;
@@ -148,6 +157,11 @@ public class Config extends YMLFile {
@Getter
private String formatCommandsVoteTodayLine = "&6%player% : %VoteSite% : %Time%";
@ConfigDataListString(path = "Format.Commands.Vote.Today.Title")
@Getter
private ArrayList<String> formatCommandsVoteTodayTitle = ArrayUtils.getInstance()
.convert(new String[] { "&cToday's Votes %page%/%maxpage%", "&cPlayerName : VoteSite : Time" });
@ConfigDataString(path = "Format.Commands.Vote.ToggleBroadcasts.Disabled")
@Getter
private String formatCommandsVoteToggleBroadcastDisabled = "&cYou will no longer see vote broadcasts";
@@ -205,7 +219,7 @@ public class Config extends YMLFile {
@ConfigDataInt(path = "MaxiumNumberOfTopVotersToLoad")
@Getter
private int MaxiumNumberOfTopVotersToLoad = -1;
private int MaxiumNumberOfTopVotersToLoad = 1000;
@ConfigDataBoolean(path = "OverrideVersionDisable")
@Getter
@@ -219,6 +233,10 @@ public class Config extends YMLFile {
@Getter
private boolean updateWithPlayersOnlineOnly = false;
@ConfigDataBoolean(path = "UseHighestTotals")
@Getter
private boolean useHighestTotals = true;
@ConfigDataBoolean(path = "UseJavascriptPlaceholders")
@Getter
private boolean useJavascriptPlaceholders = false;
@@ -227,6 +245,14 @@ public class Config extends YMLFile {
@Getter
private boolean usePrimaryAccountForPlaceholders = false;
@ConfigDataBoolean(path = "UseVoteGUIMainCommand")
@Getter
private boolean useVoteGUIMainCommand = false;
@ConfigDataBoolean(path = "UseVoteStreaks")
@Getter
private boolean useVoteStreaks = true;
@ConfigDataListString(path = "VotingBroadcastBlacklist")
@Getter
private ArrayList<String> votingBroadcastBlacklist = new ArrayList<String>();
@@ -295,6 +321,10 @@ public class Config extends YMLFile {
return getData().getString("Format.Commands.Vote.Best.Title", "&3&l%player% Best Votes");
}
public String getFormatCommandsVoteHelpHoverColor() {
return getData().getString("Format.Commands.Vote.Help.HoverColor", "AQUA");
}
/**
* Gets the commands vote help line.
*
@@ -643,14 +673,6 @@ public class Config extends YMLFile {
return getData().getBoolean("LoadTopVoter.AllTime", true);
}
@ConfigDataBoolean(path = "UseVoteStreaks")
@Getter
private boolean useVoteStreaks = true;
@ConfigDataBoolean(path = "UseHighestTotals")
@Getter
private boolean useHighestTotals = true;
public boolean getLoadTopVoterDaily() {
return getData().getBoolean("LoadTopVoter.Daily", false);
}
@@ -703,15 +725,6 @@ public class Config extends YMLFile {
return getData().getBoolean("StoreTopVoters.Daily");
}
/**
* Gets the store top voters monthly.
*
* @return the store top voters monthly
*/
public boolean getStoreTopVotersMonthly() {
return getData().getBoolean("StoreTopVoters.Monthly");
}
/**
* Gets the store top voters weekly.
*
@@ -41,8 +41,8 @@ public class ConfigVoteSites extends YMLFile {
if (plugin.getConfigFile().isAutoCreateVoteSites()) {
String org = siteName;
siteName = siteName.replace(".", "_");
plugin.getLogger().warning("VoteSite " + siteName
+ " does not exist, creating one, set AutoCreateVoteSites to false to prevent this");
plugin.getLogger().warning("VoteSite " + siteName + " does not exist with the servicesite '" + org
+ "', creating one, set AutoCreateVoteSites to false to prevent this");
setEnabled(siteName, true);
setServiceSite(siteName, org);
setVoteURL(siteName, "VoteURL");
@@ -69,6 +69,9 @@ public class ConfigVoteSites extends YMLFile {
* @return the data
*/
public ConfigurationSection getData(String siteName) {
if (!getData().isConfigurationSection("VoteSites." + siteName)) {
plugin.getLogger().warning("VoteSites." + siteName + " is not a configuration section");
}
return getData().getConfigurationSection("VoteSites." + siteName);
}
@@ -170,6 +173,14 @@ public class ConfigVoteSites extends YMLFile {
return getData(site).getBoolean("ForceOffline", getData(site).getBoolean("GiveOffline"));
}
public boolean getVoteSiteHidden(String siteName) {
return getData(siteName).getBoolean("Hidden");
}
public boolean getVoteSiteIgnoreCanVote(String siteName) {
return getData(siteName).getBoolean("IgnoreCanVote");
}
public boolean getVoteSiteResetVoteDelayDaily(String siteName) {
return getData(siteName).getBoolean("VoteDelayDaily");
}
@@ -181,7 +192,7 @@ public class ConfigVoteSites extends YMLFile {
*/
public ArrayList<VoteSite> getVoteSitesLoad() {
ArrayList<VoteSite> voteSites = new ArrayList<VoteSite>();
ArrayList<String> voteSiteNames = getVoteSitesNames();
ArrayList<String> voteSiteNames = getVoteSitesNames(true);
if (voteSiteNames != null) {
for (String site : voteSiteNames) {
if (getVoteSiteEnabled(site) && !site.equalsIgnoreCase("null")) {
@@ -214,12 +225,7 @@ public class ConfigVoteSites extends YMLFile {
return voteSites;
}
/**
* Gets the vote sites names.
*
* @return the vote sites names
*/
public ArrayList<String> getVoteSitesNames() {
public ArrayList<String> getVoteSitesNames(boolean checkEnabled) {
ArrayList<String> siteNames = new ArrayList<String>();
if (getData().isConfigurationSection("VoteSites")) {
siteNames = ArrayUtils.getInstance().convert(getData().getConfigurationSection("VoteSites").getKeys(false));
@@ -227,11 +233,14 @@ public class ConfigVoteSites extends YMLFile {
for (int i = siteNames.size() - 1; i >= 0; i--) {
// plugin.getLogger().info(siteNames.get(i));
if (!getVoteSiteEnabled(siteNames.get(i)) || siteNames.get(i).equalsIgnoreCase("null")
|| !siteCheck(siteNames.get(i))) {
if (!getData().isConfigurationSection("VoteSites." + siteNames.get(i))) {
plugin.getLogger()
.warning("VoteSites." + siteNames.get(i) + " is not a configuration section, please remove");
siteNames.remove(i);
} else if (siteNames.get(i).equalsIgnoreCase("null")
|| (!getVoteSiteEnabled(siteNames.get(i)) && checkEnabled) || !siteCheck(siteNames.get(i))) {
// plugin.getLogger().info("Removed: " + siteNames.get(i));
siteNames.remove(i);
}
}
@@ -143,16 +143,28 @@ public class GUI extends YMLFile {
private boolean lastMonthGUI = false;
private VotingPluginMain plugin;
public String getCHESTVoteShopPurchase(String identifier) {
return getData().getString("CHEST.Shop." + identifier +".PurchaseMessage", plugin.getConfigFile().getFormatShopPurchaseMsg());
}
public GUI(VotingPluginMain plugin) {
super(plugin, new File(plugin.getDataFolder(), "GUI.yml"));
this.plugin = plugin;
}
public void createShop(String value) {
ConfigurationSection shopData = getData().createSection("CHEST.Shop." + value);
shopData.set("Identifier_Name", value);
shopData.set("Material", "STONE");
shopData.set("Amount", 1);
shopData.set("Name", "&cPlaceholder item");
shopData.set("Cost", 1);
shopData.set("Permission", "");
shopData.set("CloseGUI", true);
shopData.set("RequireConfirmation", false);
shopData.set("Rewards.Items.Item1.Material", "STONE");
shopData.set("Rewards.Items.Item1.Amount", 1);
saveData();
}
public ConfigurationSection getCHESTBackButton() {
return getData().getConfigurationSection("CHEST.BackButton");
}
@@ -228,6 +240,10 @@ public class GUI extends YMLFile {
return (ArrayList<String>) getData().getList("CHEST.VoteGUI." + slot + ".Item.Lore", new ArrayList<String>());
}
public String getChestVoteGUISlotRewardsPath(String slot) {
return "CHEST.VoteGUI." + slot + ".Rewards";
}
/**
* Gets the vote GUI slots.
*
@@ -259,6 +275,10 @@ public class GUI extends YMLFile {
return getData().getBoolean("CHEST.VoteLast.BackButton");
}
public String getChestVoteLastLine() {
return getData().getString("CHEST.VoteLast.Line", "&6%timeSince%");
}
public String getChestVoteLastName() {
return getData().getString("CHEST.VoteLast.Name", "VoteLast: %player%");
}
@@ -299,6 +319,11 @@ public class GUI extends YMLFile {
return getData().getString("CHEST.Shop." + ident + ".Permission", "");
}
public String getCHESTVoteShopPurchase(String identifier) {
return getData().getString("CHEST.Shop." + identifier + ".PurchaseMessage",
plugin.getConfigFile().getFormatShopPurchaseMsg());
}
public boolean getChestVoteShopResetDaily(String shop) {
return getData().getBoolean("CHEST.Shop." + shop + ".Reset.Daily", false);
}
@@ -352,7 +377,7 @@ public class GUI extends YMLFile {
}
public boolean getChestVoteTopBackButton() {
return getData().getBoolean("CHEST.VoteToday.BackButton");
return getData().getBoolean("CHEST.VoteTop.BackButton");
}
public String getChestVoteTopItemLore() {
@@ -367,6 +392,10 @@ public class GUI extends YMLFile {
return getData().getString("CHEST.VoteTop.Name", "VoteTop %topvoter%");
}
public boolean getChestVoteTopOpenMainGUIOnClick() {
return getData().getBoolean("CHEST.VoteTop.OpenMainGUIOnClick", true);
}
public int getChestVoteTopSize() {
return getData().getInt("CHEST.VoteTop.Size", 27);
}
@@ -415,6 +444,14 @@ public class GUI extends YMLFile {
return getData().getConfigurationSection("CHEST.VoteTotal.WeekTotal.Item");
}
public int getChestVoteURLAllUrlsButtonSlot() {
return getData().getInt("CHEST.VoteURL.AllUrlsButton.Slot", -1);
}
public int getChestVoteURLAllUrlsButtonStartSlot() {
return getData().getInt("CHEST.VoteURL.StartSlot", -1);
}
public ConfigurationSection getChestVoteURLAlreadyVotedAllUrlsButtonItemSection() {
if (getData().isConfigurationSection("CHEST.VoteURL.AllUrlsButton.AlreadyVotedItem")) {
return getData().getConfigurationSection("CHEST.VoteURL.AllUrlsButton.AlreadyVotedItem");
@@ -443,6 +480,17 @@ public class GUI extends YMLFile {
return getData().getConfigurationSection("CHEST.VoteURL.CanVoteItem");
}
public Set<String> getChestVoteURLExtraItems() {
if (getData().isConfigurationSection("CHEST.VoteURL.ExtraItems")) {
return getData().getConfigurationSection("CHEST.VoteURL.ExtraItems").getKeys(false);
}
return new HashSet<String>();
}
public ConfigurationSection getChestVoteURLExtraItemsItem(String item) {
return getData().getConfigurationSection("CHEST.VoteURL.ExtraItems." + item);
}
/**
* Gets the vote URL site name.
*
@@ -452,6 +500,10 @@ public class GUI extends YMLFile {
return getData().getString("CHEST.VoteURL.SiteName", "&c%Name%");
}
public String getChestVoteURLGUISiteNameCanVote() {
return getData().getString("CHEST.VoteURL.SiteNameCanVote", "&a%Name%");
}
public String getChestVoteURLName() {
return getData().getString("CHEST.VoteURL.Name", "&cVoteURL");
}
@@ -492,6 +544,11 @@ public class GUI extends YMLFile {
return getData().getBoolean("CHEST.VoteURL.ViewAllUrlsButtonEnabled");
}
public boolean isChestVoteShopRequireConfirmation(String identifier) {
return getData().getBoolean("CHEST.Shop." + identifier + ".RequireConfirmation",
isChestVoteShopRequireConfirmation());
}
@Override
public void loadValues() {
new AnnotationHandler().load(getData(), this);
@@ -502,8 +559,8 @@ public class GUI extends YMLFile {
plugin.saveResource("GUI.yml", true);
}
public boolean isChestVoteShopRequireConfirmation(String identifier) {
return getData().getBoolean("CHEST.Shop." + identifier + ".RequireConfirmation",
isChestVoteShopRequireConfirmation());
public void removeShop(String value) {
getData().set("CHEST.Shop." + value, null);
saveData();
}
}
@@ -10,6 +10,7 @@ import com.bencodez.advancedcore.api.yml.annotation.AnnotationHandler;
import com.bencodez.advancedcore.api.yml.annotation.ConfigDataBoolean;
import com.bencodez.advancedcore.api.yml.annotation.ConfigDataDouble;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.topvoter.TopVoter;
import lombok.Getter;
@@ -36,17 +37,24 @@ public class SpecialRewardsConfig extends YMLFile {
@Getter
private String firstVoteRewardsPath = "FirstVote";
@Getter
private String firstVoteTodayRewardsPath = "FirstVoteToday";
/** The plugin. */
private VotingPluginMain plugin;
@ConfigDataBoolean(path = "VoteParty.ResetExtraVotesMonthly")
@ConfigDataBoolean(path = "VoteParty.GiveOnlinePlayersOnly")
@Getter
private boolean votePartyResetExtraVotesMonthly = false;
private boolean votePartyGiveOnlinePlayersOnly = false;
@ConfigDataBoolean(path = "VoteParty.ResetCount")
@Getter
private boolean votePartyResetCount = true;
@ConfigDataBoolean(path = "VoteParty.ResetExtraVotesMonthly")
@Getter
private boolean votePartyResetExtraVotesMonthly = false;
@Getter
private String votePartyRewardsPath = "VoteParty.Rewards";
@@ -102,18 +110,35 @@ public class SpecialRewardsConfig extends YMLFile {
* @param cumulative the cumulative
* @return the cumulative votes in same day
*/
@Deprecated
public boolean getCumulativeVotesInSameDay(int cumulative) {
return getData().getBoolean("Cumulative." + cumulative + ".VotesInSameDay");
}
@Deprecated
public boolean getCumulativeVotesInSameMonth(int cumulative) {
return getData().getBoolean("Cumulative." + cumulative + ".VotesInSameMonth");
}
@Deprecated
public boolean getCumulativeVotesInSameWeek(int cumulative) {
return getData().getBoolean("Cumulative." + cumulative + ".VotesInSameWeek");
}
public String getCumulativeVotesTotal(int cumulative) {
String str = getData().getString("Cumulative." + cumulative + ".TotalToUse", "");
if (str.isEmpty()) {
if (getCumulativeVotesInSameMonth(cumulative)) {
return TopVoter.Monthly.toString();
} else if (getCumulativeVotesInSameWeek(cumulative)) {
return TopVoter.Weekly.toString();
} else if (getCumulativeVotesInSameDay(cumulative)) {
return TopVoter.Daily.toString();
}
}
return str;
}
public String getDailyAwardRewardsPath(String path) {
return "DailyAwards." + path + ".Rewards";
}
@@ -229,18 +254,18 @@ public class SpecialRewardsConfig extends YMLFile {
return getData().getInt("VoteParty.IncreaseVotesRquired", 0);
}
public boolean getVotePartyResetEachDay() {
return getData().getBoolean("VoteParty.ResetEachDay");
}
public boolean getVotePartyOnlyOncePerDay() {
return getData().getBoolean("VoteParty.OnlyOncePerDay");
}
public boolean getVotePartyResetEachDay() {
return getData().getBoolean("VoteParty.ResetEachDay");
}
public boolean getVotePartyResetMontly() {
return getData().getBoolean("VoteParty.ResetMonthly");
}
public boolean getVotePartyResetWeekly() {
return getData().getBoolean("VoteParty.ResetWeekly");
}
@@ -304,4 +329,28 @@ public class SpecialRewardsConfig extends YMLFile {
public void onFileCreation() {
plugin.saveResource("SpecialRewards.yml", true);
}
public void removeCumulative(String votes) {
getData().set("Cumulative." + votes, null);
saveData();
}
public void removeMilestone(String votes) {
getData().set("MileStones." + votes, null);
saveData();
}
public void setCumulative(int intValue) {
getData().set("Cumulative." + intValue + ".Enabled", true);
getData().set("Cumulative." + intValue + ".TotalToUse", "AllTime");
getData().set("Cumulative." + intValue + ".Rewards.Messages.Player",
"&aYou got %cumulative% cumulative votes!");
saveData();
}
public void setMilestone(int intValue) {
getData().set("Milestones." + intValue + ".Enabled", true);
getData().set("Milestones." + intValue + ".Rewards.Messages.Player", "&aYou got %milestone% milestone votes!");
saveData();
}
}
@@ -1,6 +1,10 @@
package com.bencodez.votingplugin.cooldown;
import java.util.HashSet;
import java.util.Set;
import java.util.Timer;
import java.util.TimerTask;
import java.util.UUID;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
@@ -8,63 +12,105 @@ import org.bukkit.event.Listener;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import com.bencodez.advancedcore.api.rewards.RewardOptions;
import com.bencodez.advancedcore.api.time.events.DateChangedEvent;
import com.bencodez.advancedcore.api.user.UUID;
import com.bencodez.advancedcore.api.user.AdvancedCoreUser;
import com.bencodez.advancedcore.api.user.UserStartup;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.events.PlayerVoteCoolDownEndEvent;
import com.bencodez.votingplugin.user.UserManager;
import com.bencodez.votingplugin.user.VotingPluginUser;
// TODO: Auto-generated Javadoc
/**
* The Class VoteReminding.
*/
public class CoolDownCheck implements Listener {
private VotingPluginMain plugin;
/**
* Instantiates a new vote reminding.
*
* @param plugin the plugin
*/
private Set<UUID> uuids = new HashSet<UUID>();
public CoolDownCheck(VotingPluginMain plugin) {
this.plugin = plugin;
this.timer = new Timer();
}
public void checkAll() {
plugin.getTimer().schedule(new TimerTask() {
private Timer timer;
@Override
public void run() {
if (VotingPluginMain.plugin != null) {
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
if (VotingPluginMain.plugin != null) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
if (user.getUserData().hasData() && user.hasLoggedOnBefore()) {
user.checkCoolDownEvents();
}
} else {
cancel();
}
}
} else {
cancel();
}
private boolean cooldownCheckEnabled = false;
public void checkEnabled() {
if (!plugin.getConfigFile().isDisableCoolDownCheck() && RewardHandler.getInstance()
.hasRewards(plugin.getSpecialRewardsConfig().getData(), "VoteCoolDownEndedReward")) {
cooldownCheckEnabled = true;
} else {
cooldownCheckEnabled = false;
}
}
public void check(UUID uuid) {
check(plugin.getVotingPluginUserManager().getVotingPluginUser(uuid));
}
public void vote(VotingPluginUser user) {
if (cooldownCheckEnabled) {
UUID uuid = UUID.fromString(user.getUUID());
if (!uuids.contains(uuid)) {
schedule(user);
}
}, 1000 * 60 * 3);
}
}
public void check(VotingPluginUser user) {
boolean coolDownCheck = user.getCoolDownCheck();
if (user.canVoteAll() && coolDownCheck) {
user.setCoolDownCheck(false);
PlayerVoteCoolDownEndEvent event = new PlayerVoteCoolDownEndEvent(user);
plugin.getServer().getPluginManager().callEvent(event);
uuids.remove(UUID.fromString(user.getUUID()));
} else if (!coolDownCheck) {
schedule(user);
}
}
public void schedule(VotingPluginUser user) {
final UUID uuid = UUID.fromString(user.getUUID());
long time = user.getNextTimeAllSitesAvailable();
if (time > 0) {
user.setCoolDownCheck(true);
uuids.add(uuid);
timer.schedule(new TimerTask() {
@Override
public void run() {
check(uuid);
}
}, time * 1000 + 1500);
}
}
public void load() {
if (cooldownCheckEnabled) {
plugin.addUserStartup(new UserStartup() {
@Override
public void onStartUp(AdvancedCoreUser advancedcoreUser) {
VotingPluginUser user = plugin.getVotingPluginUserManager().getVotingPluginUser(advancedcoreUser);
check(user);
}
@Override
public void onStart() {
}
@Override
public void onFinish() {
}
});
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onCoolDownEnd(PlayerVoteCoolDownEndEvent event) {
RewardHandler.getInstance().giveReward(event.getPlayer(), plugin.getSpecialRewardsConfig().getData(),
"VoteCoolDownEndedReward",
new RewardOptions().addPlaceholder("Votesite", event.getVoteSite().getDisplayName()));
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onDayChangeEnd(DateChangedEvent event) {
checkAll();
"VoteCoolDownEndedReward", new RewardOptions());
}
}
@@ -137,6 +137,14 @@ public class ServerData {
return getData().getInt("VotePartyExtraRequired", 0);
}
public boolean isLastVotePartySameDay() {
int num = getData().getInt("LastVoteParty", 0);
if (num != plugin.getTimeChecker().getTime().getDayOfYear()) {
return true;
}
return false;
}
/**
* Next sign number.
*
@@ -233,23 +241,15 @@ public class ServerData {
saveData();
}
public void updateLastVoteParty() {
getData().set("LastVoteParty", plugin.getTimeChecker().getTime().getDayOfYear());
saveData();
}
/**
* Update values.
*/
public void updateValues() {
setVersion();
}
public boolean isLastVotePartySameDay() {
int num = getData().getInt("LastVoteParty", 0);
if (num != plugin.getTimeChecker().getTime().getDayOfYear()) {
return true;
}
return false;
}
public void updateLastVoteParty() {
getData().set("LastVoteParty", plugin.getTimeChecker().getTime().getDayOfYear());
saveData();
}
}
@@ -3,7 +3,6 @@ package com.bencodez.votingplugin.events;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import com.bencodez.votingplugin.objects.VoteSite;
import com.bencodez.votingplugin.user.VotingPluginUser;
import lombok.Getter;
@@ -35,14 +34,9 @@ public class PlayerVoteCoolDownEndEvent extends Event {
@Setter
private VotingPluginUser player;
@Getter
@Setter
private VoteSite voteSite;
public PlayerVoteCoolDownEndEvent(VotingPluginUser user, VoteSite site) {
public PlayerVoteCoolDownEndEvent(VotingPluginUser user) {
super(true);
player = user;
voteSite = site;
}
/*
@@ -72,6 +72,10 @@ public class PlayerVoteEvent extends Event {
@Setter
private VotingPluginUser votingPluginUser;
@Getter
@Setter
private boolean wasOnline;
public PlayerVoteEvent(VoteSite voteSite, String voteUsername, String serviceSite, boolean realVote) {
super(true);
this.player = voteUsername;
@@ -3,7 +3,7 @@ package com.bencodez.votingplugin.events;
import lombok.Getter;
public enum SpecialRewardType {
ALLSITE, CUMMULATIVE, FIRSTVOTE, MILESTONE, VOTESTREAK;
ALLSITE, CUMMULATIVE, FIRSTVOTE, FIRSTVOTETODAY, MILESTONE, VOTESTREAK;
@Getter
private int amount = -1;
@@ -0,0 +1,23 @@
package com.bencodez.votingplugin.listeners;
import org.bukkit.Bukkit;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.events.PlayerVoteEvent;
import com.vexsoftware.votifier.model.Vote;
import com.vexsoftware.votifier.model.VotifierEvent;
public class BungeeVotifierEvent {
public void send(VotingPluginMain plugin, PlayerVoteEvent event) {
plugin.debug("Triggering vote event");
Bukkit.getScheduler().runTask(plugin, new Runnable() {
@Override
public void run() {
VotifierEvent e = new VotifierEvent(
new Vote(event.getServiceSite(), event.getPlayer(), "VotingPlugin", "" + event.getTime()));
plugin.getServer().getPluginManager().callEvent(e);
}
});
}
}
@@ -1,53 +0,0 @@
package com.bencodez.votingplugin.listeners;
import java.util.ArrayList;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerCommandSendEvent;
import com.bencodez.votingplugin.VotingPluginMain;
// TODO: Auto-generated Javadoc
/**
* The Class PlayerJoinEvent.
*/
@Deprecated
public class PlayerCommandSendListener implements Listener {
@SuppressWarnings("unused")
private VotingPluginMain plugin;
public PlayerCommandSendListener(VotingPluginMain plugin) {
this.plugin = plugin;
}
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onTab(PlayerCommandSendEvent event) {
if (plugin.getConfigFile().isDisableAdvancedTab()) {
return;
}
ArrayList<String> removeCmds = new ArrayList<String>();
if (!VotingPluginMain.plugin.getAdvancedTab().containsKey(event.getPlayer().getUniqueId())) {
ArrayList<String> whiteListed = new ArrayList<String>();
for (String cmd : event.getCommands()) {
if (plugin.getCommandLoader().isVotingPluginCommand(event.getPlayer(), cmd)) {
if (!plugin.getCommandLoader().hasPermission(event.getPlayer(), cmd)
&& !whiteListed.contains(cmd)) {
removeCmds.add(cmd);
// plugin.debug("removed " + cmd);
} else {
removeCmds.remove(cmd);
whiteListed.add(cmd);
// plugin.debug("has " + cmd);
}
}
}
VotingPluginMain.plugin.getAdvancedTab().put(event.getPlayer().getUniqueId(), removeCmds);
} else {
removeCmds = VotingPluginMain.plugin.getAdvancedTab().get(event.getPlayer().getUniqueId());
}
event.getCommands().removeAll(removeCmds);
}
}
@@ -39,44 +39,51 @@ public class PlayerInteract implements Listener {
*/
@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.getSigns().getSigns()) {
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());
if (plugin.getConfigFile().isDisableInteractEvent()) {
return;
}
if (plugin.getSigns().getSigns().size() > 0) {
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.getSigns().getSigns()) {
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());
if (!sign.isSkullSet()) {
if (PlayerUtils.getInstance().hasServerPermission(event.getPlayer().getName(),
"VotingPlugin.Sign.Create")
|| PlayerUtils.getInstance().hasServerPermission(event.getPlayer().getName(),
"VotingPlugin.Admin")) {
player.sendMessage("Skull not set, click to set skull");
PlayerUtils.getInstance().setPlayerMeta(player, "skullset", sign.getSign());
if (!sign.isSkullSet()) {
if (PlayerUtils.getInstance().hasServerPermission(event.getPlayer().getName(),
"VotingPlugin.Sign.Create")
|| PlayerUtils.getInstance().hasServerPermission(event.getPlayer().getName(),
"VotingPlugin.Admin")) {
player.sendMessage("Skull not set, click to set skull");
PlayerUtils.getInstance().setPlayerMeta(player, "skullset", sign.getSign());
}
}
}
}
}
} else if (event.getClickedBlock().getState() instanceof Skull) {
Object ob = PlayerUtils.getInstance().getPlayerMeta(player, "skullset");
if (ob != null) {
String sign1 = (String) ob;
for (SignHandler sign : plugin.getSigns().getSigns()) {
if (sign.getSign().equals(sign1)) {
sign.setSkullLocation(event.getClickedBlock().getLocation());
sign.storeSign();
sign.checkSkulls();
player.sendMessage("Skull set");
} else if (event.getClickedBlock().getState() instanceof Skull) {
Object ob = PlayerUtils.getInstance().getPlayerMeta(player, "skullset");
if (ob != null) {
String sign1 = (String) ob;
for (SignHandler sign : plugin.getSigns().getSigns()) {
if (sign.getSign().equals(sign1)) {
sign.setSkullLocation(event.getClickedBlock().getLocation());
sign.storeSign();
sign.checkSkulls();
player.sendMessage("Skull set");
}
}
PlayerUtils.getInstance().setPlayerMeta(player, "skullset", null);
}
PlayerUtils.getInstance().setPlayerMeta(player, "skullset", null);
}
}
}
}
}
@@ -10,6 +10,7 @@ import org.bukkit.event.player.PlayerQuitEvent;
import com.bencodez.advancedcore.api.user.UserStorage;
import com.bencodez.advancedcore.listeners.AdvancedCoreLoginEvent;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.bungee.BungeeMethod;
import com.bencodez.votingplugin.user.UserManager;
import com.bencodez.votingplugin.user.VotingPluginUser;
@@ -31,6 +32,29 @@ public class PlayerJoinEvent implements Listener {
PlayerJoinEvent.plugin = plugin;
}
private void login(Player player) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(player);
if (player.isOp() && plugin.isYmlError()) {
user.sendMessage("&cVotingPlugin: Detected yml error, please check console for details");
}
boolean data = user.getData().hasData();
// run remind
user.loginMessage();
if (data) {
// give offline vote (if they voted offline)
user.offVote();
}
user.loginRewards();
if (plugin.getBungeeSettings().isUseBungeecoord()
&& plugin.getBungeeHandler().getMethod().equals(BungeeMethod.PLUGINMESSAGING)) {
plugin.getPluginMessaging().sendPluginMessage("Login", user.getPlayerName(), user.getUUID());
}
}
/**
* On player login.
*
@@ -42,24 +66,20 @@ public class PlayerJoinEvent implements Listener {
&& VotingPluginMain.plugin.getMysql() == null)) {
return;
}
Player player = event.getPlayer();
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(player);
if (player.isOp() && plugin.isYmlError()) {
user.sendMessage("&cVotingPlugin: Detected yml error, please check console for details");
int delay = plugin.getConfigFile().getDelayLoginEvent();
if (delay <= 0) {
login(event.getPlayer());
} else {
Bukkit.getScheduler().runTaskLaterAsynchronously(plugin, new Runnable() {
@Override
public void run() {
login(event.getPlayer());
}
}, delay);
}
boolean data = user.getData().hasData();
// run remind
user.loginMessage();
if (data) {
// give offline vote (if they voted offline)
user.offVote();
}
user.loginRewards();
}
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
@@ -75,6 +95,7 @@ public class PlayerJoinEvent implements Listener {
VotingPluginMain.plugin.getAdvancedTab().remove(uuid);
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(uuid);
user.dontCache();
user.logoutRewards();
}
});
@@ -64,10 +64,18 @@ public class PlayerVoteListener implements Listener {
if (event.isBungee()) {
plugin.debug("BungeePlayerVote forcebungee: " + event.isForceBungee() + ", bungeetotals: "
+ event.getBungeeTextTotals());
if (plugin.getBungeeSettings().isTriggerVotifierEvent()) {
new BungeeVotifierEvent().send(plugin, event);
}
}
VoteSite voteSite = event.getVoteSite();
if (voteSite == null) {
voteSite = plugin.getVoteSite(plugin.getVoteSiteName(true, event.getServiceSite()), true);
}
// check valid service sites
if (voteSite == null) {
if (!plugin.getConfigFile().isDisableNoServiceSiteMessage()) {
@@ -83,17 +91,22 @@ public class PlayerVoteListener implements Listener {
return;
}
if (!voteSite.isEnabled()) {
plugin.debug("Votesite: " + voteSite.getKey() + " is not enabled");
return;
}
VotingPluginUser user = null;
if (event.getVotingPluginUser() != null) {
user = event.getVotingPluginUser();
} else {
user = UserManager.getInstance().getVotingPluginUser(playerName);
}
user.updateName(true);
if (plugin.getConfigFile().isClearCacheOnVote() || plugin.getBungeeSettings().isUseBungeecoord()) {
user.clearCache();
}
// reupdate cache
user.clearCache();
user.updateName(true);
if (voteSite.isWaitUntilVoteDelay() && !user.canVoteSite(voteSite)) {
plugin.getLogger().info(user.getPlayerName() + " must wait until votedelay is over, ignoring vote");
@@ -103,7 +116,7 @@ public class PlayerVoteListener implements Listener {
synchronized (object) {
// vote party
plugin.getVoteParty().vote(user, event.isRealVote());
plugin.getVoteParty().vote(user, event.isRealVote(), event.isForceBungee());
// broadcast vote if enabled in config
if (plugin.getConfigFile().isBroadcastVotesEnabled()
@@ -113,13 +126,17 @@ public class PlayerVoteListener implements Listener {
}
}
if (plugin.getBroadcastHandler() != null) {
plugin.getBroadcastHandler().onVote(playerName);
}
// update last vote time
if (event.getTime() != 0) {
user.setTime(voteSite, event.getTime());
} else {
user.setTime(voteSite);
}
user.setLastVoteCoolDownCheck(false, voteSite);
plugin.getCoolDownCheck().vote(user);
// try logging to file
if (plugin.getConfigFile().isLogVotesToFile()) {
@@ -133,9 +150,10 @@ public class PlayerVoteListener implements Listener {
}
// check first vote rewards
plugin.getSpecialRewards().checkFirstVote(user);
plugin.getSpecialRewards().checkFirstVote(user, event.isForceBungee());
plugin.getSpecialRewards().checkFirstVoteToday(user, event.isForceBungee());
if (user.isReminded()) {
if (user.isReminded() && plugin.getConfigFile().getVoteRemindingRemindOnlyOnce()) {
user.setReminded(false);
}
@@ -143,8 +161,12 @@ public class PlayerVoteListener implements Listener {
if (((user.isOnline() || voteSite.isGiveOffline())
&& VotingPluginMain.plugin.getOptions().isProcessRewards()) || event.isBungee()) {
user.playerVote(voteSite, true, false, event.isForceBungee());
user.sendVoteEffects(true);
boolean online = true;
if (event.isBungee()) {
online = event.isWasOnline();
}
user.playerVote(voteSite, online, false, event.isForceBungee());
user.sendVoteEffects(online);
user.closeInv();
} else {
user.addOfflineVote(voteSite.getKey());
@@ -162,12 +184,12 @@ public class PlayerVoteListener implements Listener {
user.addPoints();
}
user.checkDayVoteStreak();
user.checkDayVoteStreak(event.isForceBungee());
// other rewards
plugin.getSpecialRewards().checkAllSites(user);
plugin.getSpecialRewards().checkCumualativeVotes(user, event.getBungeeTextTotals());
plugin.getSpecialRewards().checkMilestone(user, event.getBungeeTextTotals());
plugin.getSpecialRewards().checkAllSites(user, event.isForceBungee());
plugin.getSpecialRewards().checkCumualativeVotes(user, event.getBungeeTextTotals(), event.isForceBungee());
plugin.getSpecialRewards().checkMilestone(user, event.getBungeeTextTotals(), event.isForceBungee());
if (plugin.getBungeeSettings().isUseBungeecoord()) {
if (plugin.getBungeeHandler().getMethod().equals(BungeeMethod.MYSQL)) {
@@ -177,13 +199,15 @@ public class PlayerVoteListener implements Listener {
@Override
public void run() {
if (Bukkit.getOnlinePlayers().size() > 0) {
plugin.getPluginMessaging().sendPluginMessage(
PlayerUtils.getInstance().getRandomOnlinePlayer(), "VoteUpdate", uuid);
plugin.getPluginMessaging().sendPluginMessage("VoteUpdate", uuid);
}
}
}, 40);
}
}
if (!user.isOnline()) {
user.clearCache();
}
}
plugin.setUpdate(true);
@@ -9,8 +9,8 @@ import org.bukkit.event.Listener;
import com.bencodez.advancedcore.api.misc.ArrayUtils;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.bungee.BungeeMethod;
import com.bencodez.votingplugin.events.PlayerVoteEvent;
import com.bencodez.votingplugin.objects.VoteSite;
import com.vexsoftware.votifier.model.Vote;
import com.vexsoftware.votifier.model.VotifierEvent;
@@ -41,9 +41,17 @@ public class VotiferEvent implements Listener {
public void onVotiferEvent(VotifierEvent event) {
Vote vote = event.getVote();
final String voteSite = vote.getServiceName();
String str = vote.getServiceName();
if (str.isEmpty()) {
str = "Empty";
}
final String voteSite = str;
final String IP = vote.getAddress();
final String voteUsername = vote.getUsername().trim();
if (IP.equals("VotingPlugin")) {
// ignore own plugin calls of event
return;
}
Bukkit.getScheduler().runTaskAsynchronously(plugin, new Runnable() {
@Override
@@ -68,12 +76,20 @@ public class VotiferEvent implements Listener {
@Override
public void run() {
String voteSiteName = plugin.getVoteSiteName(voteSite);
ArrayList<String> sites = plugin.getConfigVoteSites().getVoteSitesNames();
if (plugin.getBungeeSettings().isUseBungeecoord() && !plugin.getBungeeSettings().isVotifierBypass()
&& (plugin.getBungeeHandler().getMethod().equals(BungeeMethod.PLUGINMESSAGING)
|| plugin.getBungeeHandler().getMethod().equals(BungeeMethod.SOCKETS))) {
plugin.getLogger().severe(
"Ignoring vote from votifier since pluginmessaging or socket bungee method is enabled, this means you aren't setup correctly for those methods");
return;
}
String voteSiteNameStr = plugin.getVoteSiteName(false, voteSite);
ArrayList<String> sites = plugin.getConfigVoteSites().getVoteSitesNames(false);
boolean createSite = false;
if (sites != null) {
if (!sites.contains(voteSiteName)) {
if (!sites.contains(voteSiteNameStr)) {
createSite = true;
}
} else {
@@ -81,19 +97,17 @@ public class VotiferEvent implements Listener {
}
if (plugin.getConfigFile().isAutoCreateVoteSites() && createSite) {
plugin.getLogger().warning("VoteSite with service site '" + voteSiteName
plugin.getLogger().warning("VoteSite with service site '" + voteSiteNameStr
+ "' does not exist, attempting to generaterate...");
plugin.getConfigVoteSites().generateVoteSite(voteSiteName);
plugin.getConfigVoteSites().generateVoteSite(voteSiteNameStr);
ArrayList<String> services = new ArrayList<String>();
for (VoteSite site : plugin.getVoteSites()) {
services.add(site.getServiceSite());
}
plugin.getLogger()
.info("Current known service sites: " + ArrayUtils.getInstance().makeStringList(services));
plugin.getLogger().info("Current known service sites: "
+ ArrayUtils.getInstance().makeStringList(plugin.getServerData().getServiceSites()));
}
PlayerVoteEvent voteEvent = new PlayerVoteEvent(plugin.getVoteSite(voteSiteName), voteUsername,
String voteSiteName = plugin.getVoteSiteName(true, voteSite);
PlayerVoteEvent voteEvent = new PlayerVoteEvent(plugin.getVoteSite(voteSiteName, true), voteUsername,
voteSite, true);
plugin.getServer().getPluginManager().callEvent(voteEvent);
@@ -13,7 +13,6 @@ 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.misc.MiscUtils;
import com.bencodez.advancedcore.api.misc.PlayerUtils;
import com.bencodez.advancedcore.api.rewards.RewardBuilder;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import com.bencodez.votingplugin.VotingPluginMain;
@@ -40,6 +39,14 @@ public class VoteSite {
@Setter
private boolean giveOffline;
@Getter
@Setter
private boolean hidden;
@Getter
@Setter
private boolean ignoreCanVote;
@Setter
private ConfigurationSection item;
@@ -97,6 +104,9 @@ public class VoteSite {
* @param checkBungee check bungee broadcast
*/
public void broadcastVote(VotingPluginUser user, boolean checkBungee) {
if (plugin.getConfigFile().isFormatAlternateBroadcastEnabled()) {
return;
}
if (!user.isVanished()) {
if (checkBungee && plugin.getBungeeSettings().isBungeeBroadcast()
&& plugin.getBungeeSettings().isUseBungeecoord()) {
@@ -108,8 +118,7 @@ public class VoteSite {
String service = getServiceSite();
if (Bukkit.getOnlinePlayers().size() > 0) {
plugin.getPluginMessaging().sendPluginMessage(PlayerUtils.getInstance().getRandomOnlinePlayer(),
"VoteBroadcast", uuid, service);
plugin.getPluginMessaging().sendPluginMessage("VoteBroadcast", uuid, service);
}
}
@@ -223,6 +232,8 @@ public class VoteSite {
giveOffline = plugin.getConfigVoteSites().getVoteSiteGiveOffline(key);
waitUntilVoteDelay = plugin.getConfigVoteSites().getWaitUntilVoteDelay(key);
timeOffSet = plugin.getConfigVoteSites().getTimeOffSet(key);
hidden = plugin.getConfigVoteSites().getVoteSiteHidden(key);
ignoreCanVote = plugin.getConfigVoteSites().getVoteSiteIgnoreCanVote(key);
}
public boolean isVaidServiceSite() {
@@ -1,6 +1,8 @@
package com.bencodez.votingplugin.placeholders;
import java.text.NumberFormat;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Locale;
@@ -15,6 +17,7 @@ import com.bencodez.advancedcore.api.placeholder.PlaceHolder;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.objects.VoteSite;
import com.bencodez.votingplugin.topvoter.TopVoter;
import com.bencodez.votingplugin.topvoter.TopVoterPlayer;
import com.bencodez.votingplugin.user.UserManager;
import com.bencodez.votingplugin.user.VotingPluginUser;
@@ -39,7 +42,11 @@ public class PlaceHolders {
}
public String getPlaceHolder(OfflinePlayer p, String identifier) {
if (plugin.getConfigFile().isUseJavascriptPlaceholders()) {
return getPlaceHolder(p, identifier, true);
}
public String getPlaceHolder(OfflinePlayer p, String identifier, boolean javascript) {
if (plugin.getConfigFile().isUseJavascriptPlaceholders() && javascript) {
identifier = StringParser.getInstance().replaceJavascript(p, identifier);
}
@@ -50,14 +57,15 @@ public class PlaceHolders {
}
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(p);
if (Bukkit.isPrimaryThread()) {
if (Bukkit.isPrimaryThread() || plugin.getConfigFile().isAlwaysWaitForCachePlaceholders()) {
user.setWaitForCache(false);
if (!user.isCached()) {
user.loadCache();
return "..";
}
}
if (plugin.getConfigFile().isUsePrimaryAccountForPlaceholders() && user.hasPrimaryAccount()) {
user = UserManager.getInstance().getVotingPluginUser(user.getPrimaryAccount());
if (Bukkit.isPrimaryThread()) {
user.setWaitForCache(false);
}
}
for (PlaceHolder<VotingPluginUser> placeholder : placeholders) {
@@ -78,7 +86,7 @@ public class PlaceHolders {
if (plugin.getConfigFile().isUseJavascriptPlaceholders()) {
identifier = StringParser.getInstance().replaceJavascript(p, identifier);
}
return getPlaceHolder((OfflinePlayer) p, identifier);
return getPlaceHolder((OfflinePlayer) p, identifier, false);
}
public void load() {
@@ -247,6 +255,14 @@ public class PlaceHolders {
}
}.withDescription("Return true/false if player can vote on all sites"));
placeholders.add(new PlaceHolder<VotingPluginUser>("CanVoteSites") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
return "" + user.getSitesNotVotedOn();
}
}.withDescription("Return number of votesites available"));
placeholders.add(new PlaceHolder<VotingPluginUser>("Next_AnySite") {
@Override
@@ -305,8 +321,8 @@ public class PlaceHolders {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
int num = 1;
for (Entry<VotingPluginUser, Integer> entry : plugin.getTopVoter(TopVoter.AllTime).entrySet()) {
if (entry.getKey().getUUID().equals(p.getUniqueId().toString())) {
for (Entry<TopVoterPlayer, Integer> entry : plugin.getTopVoter(TopVoter.AllTime).entrySet()) {
if (entry.getKey().getUuid().equals(p.getUniqueId())) {
return "" + num;
}
num++;
@@ -321,9 +337,9 @@ public class PlaceHolders {
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
int num = 1;
int number = Integer.parseInt(identifier.split("_")[2]);
for (Entry<VotingPluginUser, Integer> entry : plugin.getTopVoter(TopVoter.AllTime).entrySet()) {
for (Entry<TopVoterPlayer, Integer> entry : plugin.getTopVoter(TopVoter.AllTime).entrySet()) {
if (num == number) {
return "" + entry.getKey().getTotal(TopVoter.AllTime);
return "" + entry.getValue().intValue();
}
num++;
}
@@ -337,7 +353,7 @@ public class PlaceHolders {
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
int num = 1;
int number = Integer.parseInt(identifier.split("_")[2]);
for (Entry<VotingPluginUser, Integer> entry : plugin.getTopVoter(TopVoter.AllTime).entrySet()) {
for (Entry<TopVoterPlayer, Integer> entry : plugin.getTopVoter(TopVoter.AllTime).entrySet()) {
if (num == number) {
return entry.getKey().getPlayerName();
}
@@ -352,8 +368,8 @@ public class PlaceHolders {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
int num = 1;
for (Entry<VotingPluginUser, Integer> entry : plugin.getTopVoter(TopVoter.Monthly).entrySet()) {
if (entry.getKey().getUUID().equals(p.getUniqueId().toString())) {
for (Entry<TopVoterPlayer, Integer> entry : plugin.getTopVoter(TopVoter.Monthly).entrySet()) {
if (entry.getKey().getUuid().equals(p.getUniqueId())) {
return "" + num;
}
num++;
@@ -368,7 +384,7 @@ public class PlaceHolders {
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
int num = 1;
int number = Integer.parseInt(identifier.split("_")[2]);
for (Entry<VotingPluginUser, Integer> entry : plugin.getTopVoter(TopVoter.Monthly).entrySet()) {
for (Entry<TopVoterPlayer, Integer> entry : plugin.getTopVoter(TopVoter.Monthly).entrySet()) {
if (num == number) {
return entry.getKey().getPlayerName();
}
@@ -384,9 +400,9 @@ public class PlaceHolders {
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
int num = 1;
int number = Integer.parseInt(identifier.split("_")[2]);
for (Entry<VotingPluginUser, Integer> entry : plugin.getTopVoter(TopVoter.Monthly).entrySet()) {
for (Entry<TopVoterPlayer, Integer> entry : plugin.getTopVoter(TopVoter.Monthly).entrySet()) {
if (num == number) {
return "" + entry.getKey().getTotal(TopVoter.Monthly);
return "" + entry.getValue().intValue();
}
num++;
}
@@ -399,8 +415,8 @@ public class PlaceHolders {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
int num = 1;
for (Entry<VotingPluginUser, Integer> entry : plugin.getTopVoter(TopVoter.Weekly).entrySet()) {
if (entry.getKey().getUUID().equals(p.getUniqueId().toString())) {
for (Entry<TopVoterPlayer, Integer> entry : plugin.getTopVoter(TopVoter.Weekly).entrySet()) {
if (entry.getKey().getUuid().equals(p.getUniqueId())) {
return "" + num;
}
num++;
@@ -415,7 +431,7 @@ public class PlaceHolders {
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
int num = 1;
int number = Integer.parseInt(identifier.split("_")[2]);
for (Entry<VotingPluginUser, Integer> entry : plugin.getTopVoter(TopVoter.Weekly).entrySet()) {
for (Entry<TopVoterPlayer, Integer> entry : plugin.getTopVoter(TopVoter.Weekly).entrySet()) {
if (num == number) {
return entry.getKey().getPlayerName();
}
@@ -431,9 +447,9 @@ public class PlaceHolders {
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
int num = 1;
int number = Integer.parseInt(identifier.split("_")[2]);
for (Entry<VotingPluginUser, Integer> entry : plugin.getTopVoter(TopVoter.Weekly).entrySet()) {
for (Entry<TopVoterPlayer, Integer> entry : plugin.getTopVoter(TopVoter.Weekly).entrySet()) {
if (num == number) {
return "" + entry.getKey().getTotal(TopVoter.Weekly);
return "" + entry.getValue().intValue();
}
num++;
}
@@ -446,8 +462,8 @@ public class PlaceHolders {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
int num = 1;
for (Entry<VotingPluginUser, Integer> entry : plugin.getTopVoter(TopVoter.Daily).entrySet()) {
if (entry.getKey().getUUID().equals(p.getUniqueId().toString())) {
for (Entry<TopVoterPlayer, Integer> entry : plugin.getTopVoter(TopVoter.Daily).entrySet()) {
if (entry.getKey().getUuid().equals(p.getUniqueId())) {
return "" + num;
}
num++;
@@ -462,7 +478,7 @@ public class PlaceHolders {
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
int num = 1;
int number = Integer.parseInt(identifier.split("_")[2]);
for (Entry<VotingPluginUser, Integer> entry : plugin.getTopVoter(TopVoter.Daily).entrySet()) {
for (Entry<TopVoterPlayer, Integer> entry : plugin.getTopVoter(TopVoter.Daily).entrySet()) {
if (num == number) {
return entry.getKey().getPlayerName();
}
@@ -486,9 +502,9 @@ public class PlaceHolders {
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
int num = 1;
int number = Integer.parseInt(identifier.split("_")[2]);
for (Entry<VotingPluginUser, Integer> entry : plugin.getTopVoter(TopVoter.Daily).entrySet()) {
for (Entry<TopVoterPlayer, Integer> entry : plugin.getTopVoter(TopVoter.Daily).entrySet()) {
if (num == number) {
return "" + entry.getKey().getTotal(TopVoter.Daily);
return "" + entry.getValue().intValue();
}
num++;
}
@@ -569,5 +585,43 @@ public class PlaceHolders {
return Integer.toString(total);
}
}.withDescription("Global daily total"));
nonPlayerPlaceholders.add(new PlaceHolder<VotingPluginUser>("TimeUntilDayReset") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
LocalDateTime now = LocalDateTime.now();
LocalDateTime offsetoclocktoday = plugin.getTimeChecker().getTime().withHour(0).withMinute(0);
LocalDateTime offsetoclocktomorrow = plugin.getTimeChecker().getTime().plusDays(1).withHour(0)
.withMinute(0);
String timeMsg = "%hours% Hours %minutes% Minutes";
Duration dur = null;
if (!now.isBefore(offsetoclocktoday)) {
dur = Duration.between(now, offsetoclocktomorrow);
} else {
dur = Duration.between(now, offsetoclocktoday);
}
int diffHours = (int) (dur.getSeconds() / (60 * 60));
long diffMinutes = dur.getSeconds() / 60 - diffHours * 60;
if (diffHours < 0) {
diffHours = diffHours * -1;
}
if (diffHours >= 24) {
diffHours = diffHours - 24;
}
if (diffMinutes < 0) {
diffMinutes = diffMinutes * -1;
}
timeMsg = StringParser.getInstance().replaceIgnoreCase(timeMsg, "%hours%", Integer.toString(diffHours));
timeMsg = StringParser.getInstance().replaceIgnoreCase(timeMsg, "%minutes%",
Long.toString(diffMinutes));
return timeMsg;
}
}.withDescription("Time until plugin time day changes"));
}
}
@@ -16,7 +16,7 @@ import com.bencodez.advancedcore.api.misc.MiscUtils;
import com.bencodez.advancedcore.nms.NMSManager;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.topvoter.TopVoter;
import com.bencodez.votingplugin.user.VotingPluginUser;
import com.bencodez.votingplugin.topvoter.TopVoterPlayer;
import lombok.Getter;
import lombok.Setter;
@@ -79,9 +79,11 @@ public class SignHandler {
@SuppressWarnings("deprecation")
private boolean checkSkull(Block block) {
if (block.getState() instanceof Skull) {
Skull skull = (Skull) block.getState();
skull.setOwner(playerName);
skull.update();
if (!playerName.equals("No Player")) {
Skull skull = (Skull) block.getState();
skull.setOwner(playerName);
skull.update();
}
return true;
}
return false;
@@ -91,7 +93,7 @@ public class SignHandler {
* Check skulls.
*/
public void checkSkulls() {
if (playerName.equalsIgnoreCase("No Player") || playerName.equals("")) {
if (noNameAvailable()) {
return;
}
if (skullLocation != null) {
@@ -151,6 +153,10 @@ public class SignHandler {
return skullLocation != null;
}
public boolean noNameAvailable() {
return playerName.equalsIgnoreCase("No Player") || playerName.equals("");
}
/**
* Removes the sign.
*/
@@ -181,7 +187,7 @@ public class SignHandler {
lines.add(line3);
lines.add(line4);
ArrayList<VotingPluginUser> users = null;
ArrayList<TopVoterPlayer> users = null;
if (data.equalsIgnoreCase("all")) {
users = plugin.convertSet(plugin.getTopVoter(TopVoter.AllTime).keySet());
} else if (data.equalsIgnoreCase("monthly")) {
@@ -193,7 +199,7 @@ public class SignHandler {
}
if (users != null && users.size() >= position) {
VotingPluginUser user = users.get(position - 1);
TopVoterPlayer user = users.get(position - 1);
playerName = user.getPlayerName();
votes = 0;
@@ -251,6 +257,7 @@ public class SignHandler {
}
} catch (Exception ex) {
plugin.debug("Failed to update sign at " + getLocation().toString());
VotingPluginMain.plugin.debug(ex);
}
}
@@ -81,7 +81,7 @@ public class Signs {
}
}
plugin.debug("Signs updated");
plugin.debug(getSigns().size() + " Signs updated");
}
}
@@ -1,5 +1,6 @@
package com.bencodez.votingplugin.specialrewards;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Set;
@@ -28,21 +29,28 @@ public class SpecialRewards {
this.plugin = plugin;
}
/**
* Check all sites.
*
* @param user the user
* @return true, if successful
*/
public boolean checkAllSites(VotingPluginUser user) {
public boolean checkAllSites(VotingPluginUser user, boolean forceBungee) {
boolean checkAllVotes = user.checkAllVotes();
if (checkAllVotes
&& (plugin.getConfigFile().isExtraAllSitesCheck() || plugin.getBungeeSettings().isUseBungeecoord())) {
int currentDay = LocalDateTime.now().getDayOfYear();
int day = user.getGottenAllSitesDay();
if (currentDay == day) {
checkAllVotes = false;
plugin.debug("Not giving allsites, already gotten today");
} else {
user.setGottenAllSitesDay(currentDay);
}
}
if (checkAllVotes) {
giveAllSitesRewards(user, user.isOnline());
giveAllSitesRewards(user, user.isOnline(), forceBungee);
}
return checkAllVotes;
}
public boolean checkCumualativeVotes(VotingPluginUser user, BungeeMessageData bungeeMessageData) {
public boolean checkCumualativeVotes(VotingPluginUser user, BungeeMessageData bungeeMessageData,
boolean forceBungee) {
boolean gotCumulativeAny = false;
Set<String> votes = plugin.getSpecialRewardsConfig().getCumulativeVotes();
for (String vote : votes) {
@@ -55,29 +63,27 @@ public class SpecialRewards {
boolean gotCumulative = false;
int total = 0;
boolean useBungeeTotalNum = bungeeMessageData != null;
if (plugin.getSpecialRewardsConfig().getCumulativeVotesInSameDay(votesRequired)) {
if (!useBungeeTotalNum) {
total = user.getTotal(TopVoter.Daily);
} else {
total = bungeeMessageData.getDailyTotal();
}
} else if (plugin.getSpecialRewardsConfig().getCumulativeVotesInSameWeek(votesRequired)) {
if (!useBungeeTotalNum) {
total = user.getTotal(TopVoter.Weekly);
} else {
total = bungeeMessageData.getWeeklyTotal();
}
} else if (plugin.getSpecialRewardsConfig().getCumulativeVotesInSameMonth(votesRequired)) {
if (!useBungeeTotalNum) {
total = user.getTotal(TopVoter.Monthly);
} else {
total = bungeeMessageData.getMonthTotal();
}
String totalToUse = plugin.getSpecialRewardsConfig().getCumulativeVotesTotal(votesRequired);
TopVoter top = TopVoter.getTopVoter(totalToUse);
if (!useBungeeTotalNum) {
total = user.getTotal(top);
} else {
if (!useBungeeTotalNum) {
total = user.getTotal(TopVoter.AllTime);
} else {
switch (top) {
case AllTime:
total = bungeeMessageData.getAllTimeTotal();
break;
case Daily:
total = bungeeMessageData.getDailyTotal();
break;
case Monthly:
total = bungeeMessageData.getMonthTotal();
break;
case Weekly:
total = bungeeMessageData.getWeeklyTotal();
break;
default:
break;
}
}
@@ -89,10 +95,12 @@ public class SpecialRewards {
if (gotCumulative) {
gotCumulativeAny = true;
giveCumulativeVoteReward(user, user.isOnline(), votesRequired);
plugin.debug(user.getPlayerName() + " got cumulative " + votesRequired);
plugin.debug(user.getPlayerName() + " got cumulative " + votesRequired + ", total: "
+ top.toString() + ", current total: " + total);
giveCumulativeVoteReward(user, user.isOnline(), votesRequired, forceBungee);
} else {
plugin.devDebug(user.getPlayerName() + " not able to get cumulative " + votesRequired);
plugin.devDebug(user.getPlayerName() + " not able to get cumulative " + votesRequired
+ ", total required: " + top.toString() + ", current player total: " + total);
}
}
}
@@ -103,17 +111,11 @@ public class SpecialRewards {
return gotCumulativeAny;
}
/**
* Check first vote.
*
* @param user the user
* @return true, if successful
*/
public boolean checkFirstVote(VotingPluginUser user) {
public boolean checkFirstVote(VotingPluginUser user, boolean forceBungee) {
if (RewardHandler.getInstance().hasRewards(plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getFirstVoteRewardsPath())) {
if (!user.hasGottenFirstVote()) {
giveFirstVoteRewards(user, user.isOnline());
giveFirstVoteRewards(user, user.isOnline(), forceBungee);
return true;
}
@@ -121,7 +123,19 @@ public class SpecialRewards {
return false;
}
public boolean checkMilestone(VotingPluginUser user, BungeeMessageData bungeeMessageData) {
public boolean checkFirstVoteToday(VotingPluginUser user, boolean forceBungee) {
if (RewardHandler.getInstance().hasRewards(plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getFirstVoteRewardsPath())) {
if (!user.hasGottenFirstVoteToday()) {
giveFirstVoteTodayRewards(user, user.isOnline(), forceBungee);
return true;
}
}
return false;
}
public boolean checkMilestone(VotingPluginUser user, BungeeMessageData bungeeMessageData, boolean forceBungee) {
int milestoneCount = user.getMilestoneCount();
if (bungeeMessageData != null) {
try {
@@ -168,7 +182,7 @@ public class SpecialRewards {
int userVotesTotal = milestoneCount;
if (userVotesTotal >= votesRequired && !user.hasGottenMilestone(votesRequired)) {
giveMilestoneVoteReward(user, user.isOnline(), votesRequired);
giveMilestoneVoteReward(user, user.isOnline(), votesRequired, forceBungee);
user.setHasGotteMilestone(votesRequired, true);
plugin.debug(user.getPlayerName() + " got milestone " + votesRequired);
@@ -182,7 +196,7 @@ public class SpecialRewards {
return gotMilestone;
}
public boolean checkVoteStreak(VotingPluginUser user, String type) {
public boolean checkVoteStreak(VotingPluginUser user, String type, boolean forceBungee) {
boolean gotReward = false;
Set<String> streaks = plugin.getSpecialRewardsConfig().getVoteStreakVotes(type);
@@ -209,14 +223,16 @@ public class SpecialRewards {
}
if (!multiple) {
if (curStreak == streakRequired) {
giveVoteStreakReward(user, user.isOnline(), type, "" + streakRequired, curStreak);
giveVoteStreakReward(user, user.isOnline(), type, "" + streakRequired, curStreak,
forceBungee);
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);
giveVoteStreakReward(user, user.isOnline(), type, streakRequired + "-", curStreak,
forceBungee);
gotReward = true;
plugin.debug(
user.getPlayerName() + " got VoteStreak " + streakRequired + "* for " + type);
@@ -232,13 +248,7 @@ public class SpecialRewards {
}
/**
* Give all sites rewards.
*
* @param user the user
* @param online the online
*/
public void giveAllSitesRewards(VotingPluginUser user, boolean online) {
public void giveAllSitesRewards(VotingPluginUser user, boolean online, boolean forceBungee) {
PlayerSpecialRewardEvent event = new PlayerSpecialRewardEvent(user, SpecialRewardType.ALLSITE);
Bukkit.getPluginManager().callEvent(event);
@@ -246,17 +256,11 @@ public class SpecialRewards {
return;
}
RewardHandler.getInstance().giveReward(user, plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getAllSitesRewardPath(), new RewardOptions().setOnline(online));
plugin.getSpecialRewardsConfig().getAllSitesRewardPath(),
new RewardOptions().setServer(forceBungee).setOnline(online));
}
/**
* Give cumulative vote reward.
*
* @param user the user
* @param online the online
* @param cumulative the cumulative
*/
public void giveCumulativeVoteReward(VotingPluginUser user, boolean online, int cumulative) {
public void giveCumulativeVoteReward(VotingPluginUser user, boolean online, int cumulative, boolean forceBungee) {
PlayerSpecialRewardEvent event = new PlayerSpecialRewardEvent(user,
SpecialRewardType.CUMMULATIVE.setAmount(cumulative));
Bukkit.getPluginManager().callEvent(event);
@@ -266,17 +270,11 @@ public class SpecialRewards {
}
new RewardBuilder(plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getCumulativeRewardsPath(cumulative)).setOnline(online)
.withPlaceHolder("Cumulative", "" + cumulative).send(user);
plugin.getSpecialRewardsConfig().getCumulativeRewardsPath(cumulative)).setServer(forceBungee)
.setOnline(online).withPlaceHolder("Cumulative", "" + cumulative).send(user);
}
/**
* Give first vote rewards.
*
* @param user the user
* @param online the online
*/
public void giveFirstVoteRewards(VotingPluginUser user, boolean online) {
public void giveFirstVoteRewards(VotingPluginUser user, boolean online, boolean forceBungee) {
PlayerSpecialRewardEvent event = new PlayerSpecialRewardEvent(user, SpecialRewardType.FIRSTVOTE);
Bukkit.getPluginManager().callEvent(event);
@@ -284,17 +282,23 @@ public class SpecialRewards {
return;
}
RewardHandler.getInstance().giveReward(user, plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getFirstVoteRewardsPath(), new RewardOptions().setOnline(online));
plugin.getSpecialRewardsConfig().getFirstVoteRewardsPath(),
new RewardOptions().setServer(forceBungee).setOnline(online));
}
/**
* Give milestone vote reward.
*
* @param user the user
* @param online the online
* @param milestone the milestone
*/
public void giveMilestoneVoteReward(VotingPluginUser user, boolean online, int milestone) {
public void giveFirstVoteTodayRewards(VotingPluginUser user, boolean online, boolean forceBungee) {
PlayerSpecialRewardEvent event = new PlayerSpecialRewardEvent(user, SpecialRewardType.FIRSTVOTETODAY);
Bukkit.getPluginManager().callEvent(event);
if (event.isCancelled()) {
return;
}
RewardHandler.getInstance().giveReward(user, plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getFirstVoteTodayRewardsPath(),
new RewardOptions().setServer(forceBungee).setOnline(online));
}
public void giveMilestoneVoteReward(VotingPluginUser user, boolean online, int milestone, boolean forceBungee) {
PlayerSpecialRewardEvent event = new PlayerSpecialRewardEvent(user,
SpecialRewardType.MILESTONE.setAmount(milestone));
Bukkit.getPluginManager().callEvent(event);
@@ -304,10 +308,11 @@ public class SpecialRewards {
}
new RewardBuilder(plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getMilestoneRewardsPath(milestone)).setOnline(online)
.withPlaceHolder("Milestone", "" + milestone).send(user);
.withPlaceHolder("Milestone", "" + milestone).setServer(forceBungee).send(user);
}
public void giveVoteStreakReward(VotingPluginUser user, boolean online, String type, String string, int votes) {
public void giveVoteStreakReward(VotingPluginUser user, boolean online, String type, String string, int votes,
boolean forceBungee) {
PlayerSpecialRewardEvent event = new PlayerSpecialRewardEvent(user,
SpecialRewardType.VOTESTREAK.setType(type).setAmount(votes));
Bukkit.getPluginManager().callEvent(event);
@@ -317,7 +322,8 @@ public class SpecialRewards {
}
new RewardBuilder(plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getVoteStreakRewardsPath(type, string)).setOnline(online)
.withPlaceHolder("Type", type).withPlaceHolder("Streak", "" + votes).send(user);
.withPlaceHolder("Type", type).setServer(forceBungee).withPlaceHolder("Streak", "" + votes)
.send(user);
}
}
@@ -52,7 +52,7 @@ public class VoteTester {
ArrayList<Long> timesPerVote = new ArrayList<Long>();
for (int i = 0; i < amount; i++) {
long start1 = System.currentTimeMillis();
PlayerVoteEvent voteEvent = new PlayerVoteEvent(plugin.getVoteSite(site), name,
PlayerVoteEvent voteEvent = new PlayerVoteEvent(plugin.getVoteSite(site, false), name,
plugin.getVoteSiteServiceSite(site), false);
plugin.getServer().getPluginManager().callEvent(voteEvent);
long start2 = System.currentTimeMillis();
@@ -5,7 +5,7 @@ import java.util.ArrayList;
import com.bencodez.votingplugin.VotingPluginMain;
public enum TopVoter {
AllTime, Daily, Monthly, Weekly;
AllTime, Monthly, Weekly, Daily;
public static TopVoter getDefault() {
TopVoter top = getTopVoter(VotingPluginMain.plugin.getConfigFile().getVoteTopDefault());
@@ -28,6 +28,22 @@ public enum TopVoter {
return new TopVoter[] { TopVoter.Daily, TopVoter.Weekly, TopVoter.Monthly };
}
public String getColumnName() {
switch (this) {
case AllTime:
return "AllTimeTotal";
case Daily:
return "DailyTotal";
case Monthly:
return "MonthTotal";
case Weekly:
return "WeeklyTotal";
default:
return null;
}
}
public String getName() {
if (this.equals(TopVoter.Monthly)) {
return VotingPluginMain.plugin.getConfigFile().getFormatTopVoterMonthly();
@@ -91,20 +107,4 @@ public enum TopVoter {
}
return TopVoter.AllTime;
}
public String getColumnName() {
switch (this) {
case AllTime:
return "AllTimeTotal";
case Daily:
return "DailyTotal";
case Monthly:
return "MonthTotal";
case Weekly:
return "WeeklyTotal";
default:
return null;
}
}
}
@@ -11,6 +11,7 @@ import java.util.LinkedList;
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;
import java.util.UUID;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
@@ -24,8 +25,8 @@ import com.bencodez.advancedcore.api.time.events.DayChangeEvent;
import com.bencodez.advancedcore.api.time.events.MonthChangeEvent;
import com.bencodez.advancedcore.api.time.events.PreDateChangedEvent;
import com.bencodez.advancedcore.api.time.events.WeekChangeEvent;
import com.bencodez.advancedcore.api.user.UUID;
import com.bencodez.advancedcore.api.user.UserStorage;
import com.bencodez.advancedcore.api.user.userstorage.DataType;
import com.bencodez.advancedcore.api.yml.YMLFileHandler;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.user.UserManager;
@@ -51,7 +52,7 @@ public class TopVoterHandler implements Listener {
public String[] getTopVotersWeekly() {
ArrayList<String> msg = new ArrayList<String>();
ArrayList<VotingPluginUser> users = plugin.convertSet(plugin.getTopVoter(TopVoter.Weekly).keySet());
ArrayList<TopVoterPlayer> users = plugin.convertSet(plugin.getTopVoter(TopVoter.Weekly).keySet());
for (int i = 0; i < users.size(); i++) {
String line = plugin.getConfigFile().getFormatCommandVoteTopLine().replace("%num%", "" + (i + 1))
.replace("%player%", users.get(i).getPlayerName())
@@ -85,13 +86,13 @@ public class TopVoterHandler implements Listener {
public void loadLastMonth() {
if (plugin.getGui().isLastMonthGUI()) {
plugin.getLastMonthTopVoter().clear();
LinkedHashMap<VotingPluginUser, Integer> totals = new LinkedHashMap<VotingPluginUser, Integer>();
LinkedHashMap<TopVoterPlayer, Integer> totals = new LinkedHashMap<TopVoterPlayer, Integer>();
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(UUID.fromString(uuid));
user.dontCache();
int total = user.getLastMonthTotal();
if (total > 0) {
totals.put(user, total);
totals.put(user.getTopVoterPlayer(), total);
}
}
@@ -110,15 +111,20 @@ public class TopVoterHandler implements Listener {
loadLastMonth();
}
if (plugin.getStorageType().equals(UserStorage.MYSQL)) {
plugin.getMysql().clearCache();
plugin.getMysql().clearCacheBasic();
}
plugin.getUserManager().getDataManager().clearCache();
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onDayChange(DayChangeEvent event) {
synchronized (VotingPluginMain.plugin) {
long startTime = System.currentTimeMillis();
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(UUID.fromString(uuid), false);
user.dontCache();
user.tempCache();
user.getUserData().updateCacheWithTemp();
if (plugin.getConfigFile().isUseVoteStreaks()) {
if (!user.voteStreakUpdatedToday(LocalDateTime.now().minusDays(1))) {
if (user.getDayVoteStreak() != 0) {
@@ -132,11 +138,7 @@ public class TopVoterHandler implements Listener {
user.setHighestDailyTotal(user.getTotal(TopVoter.Daily));
}
}
for (String shopIdent : plugin.getGui().getChestShopIdentifiers()) {
if (plugin.getGui().getChestVoteShopResetDaily(shopIdent)) {
user.setVoteShopIdentifierLimit(shopIdent, 0);
}
}
user.clearTempCache();
}
if (plugin.getConfigFile().getStoreTopVotersDaily()) {
@@ -151,12 +153,14 @@ public class TopVoterHandler implements Listener {
int i = 0;
int lastTotal = -1;
@SuppressWarnings("unchecked")
LinkedHashMap<VotingPluginUser, Integer> clone = (LinkedHashMap<VotingPluginUser, Integer>) plugin
LinkedHashMap<TopVoterPlayer, Integer> clone = (LinkedHashMap<TopVoterPlayer, Integer>) plugin
.getTopVoter(TopVoter.Daily).clone();
for (VotingPluginUser user : clone.keySet()) {
for (Entry<TopVoterPlayer, Integer> entry : clone.entrySet()) {
VotingPluginUser user = entry.getKey().getUser();
user.dontCache();
if (!plugin.getConfigFile().getTopVoterIgnorePermission() || !user.isTopVoterIgnore()) {
if (plugin.getConfigFile().getTopVoterAwardsTies()) {
if (user.getTotal(TopVoter.Daily) != lastTotal) {
if (entry.getValue().intValue() != lastTotal) {
i++;
}
} else {
@@ -166,26 +170,42 @@ public class TopVoterHandler implements Listener {
user.giveDailyTopVoterAward(i, places.get(i));
}
}
lastTotal = user.getTotal(TopVoter.Daily);
lastTotal = entry.getValue().intValue();
}
}
} catch (Exception e) {
e.printStackTrace();
}
for (String shopIdent : plugin.getGui().getChestShopIdentifiers()) {
if (plugin.getGui().getChestVoteShopResetDaily(shopIdent)) {
resetVoteShopLimit(shopIdent);
}
}
resetTotals(TopVoter.Daily);
if (plugin.getStorageType().equals(UserStorage.MYSQL)) {
plugin.getMysql().clearCache();
plugin.getMysql().clearCacheBasic();
}
plugin.getUserManager().getDataManager().clearCache();
long now = ((System.currentTimeMillis() - startTime) / 1000);
plugin.getLogger().info("Finished processing day change, took " + now + " seconds");
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onMonthChange(MonthChangeEvent event) {
long startTime = System.currentTimeMillis();
synchronized (VotingPluginMain.plugin) {
plugin.getLogger().info("Saving TopVoters Monthly");
storeTopVoters(TopVoter.Monthly);
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(UUID.fromString(uuid), false);
user.dontCache();
user.tempCache();
user.getUserData().updateCacheWithTemp();
if (plugin.getConfigFile().isUseVoteStreaks()) {
if (user.getTotal(TopVoter.Monthly) == 0 && user.getMonthVoteStreak() != 0) {
user.setMonthVoteStreak(0);
@@ -195,17 +215,12 @@ public class TopVoterHandler implements Listener {
plugin.getSpecialRewardsConfig().getVoteStreakRequirementMonth(),
LocalDateTime.now().minusDays(1))) {
user.addMonthVoteStreak();
plugin.getSpecialRewards().checkVoteStreak(user, "Month");
plugin.getSpecialRewards().checkVoteStreak(user, "Month",
plugin.getBungeeSettings().isUseBungeecoord());
}
}
}
for (String shopIdent : plugin.getGui().getChestShopIdentifiers()) {
if (plugin.getGui().getChestVoteShopResetMonthly(shopIdent)) {
user.setVoteShopIdentifierLimit(shopIdent, 0);
}
}
user.setLastMonthTotal(user.getTotal(TopVoter.Monthly));
if (plugin.getConfigFile().isUseHighestTotals()) {
@@ -213,11 +228,7 @@ public class TopVoterHandler implements Listener {
user.setHighestMonthlyTotal(user.getTotal(TopVoter.Monthly));
}
}
}
if (plugin.getConfigFile().getStoreTopVotersMonthly()) {
plugin.getLogger().info("Saving TopVoters Monthly");
storeTopVoters(TopVoter.Monthly);
user.clearTempCache();
}
try {
@@ -228,13 +239,14 @@ public class TopVoterHandler implements Listener {
int lastTotal = -1;
@SuppressWarnings("unchecked")
LinkedHashMap<VotingPluginUser, Integer> clone = (LinkedHashMap<VotingPluginUser, Integer>) plugin
LinkedHashMap<TopVoterPlayer, Integer> clone = (LinkedHashMap<TopVoterPlayer, Integer>) plugin
.getTopVoter(TopVoter.Monthly).clone();
for (VotingPluginUser user : clone.keySet()) {
for (Entry<TopVoterPlayer, Integer> entry : clone.entrySet()) {
VotingPluginUser user = entry.getKey().getUser();
user.dontCache();
if (!plugin.getConfigFile().getTopVoterIgnorePermission() || !user.isTopVoterIgnore()) {
if (plugin.getConfigFile().getTopVoterAwardsTies()) {
if (user.getTotal(TopVoter.Monthly) != lastTotal) {
if (entry.getValue().intValue() != lastTotal) {
i++;
}
} else {
@@ -244,7 +256,7 @@ public class TopVoterHandler implements Listener {
user.giveMonthlyTopVoterAward(i, places.get(i));
}
}
lastTotal = user.getTotal(TopVoter.Monthly);
lastTotal = entry.getValue().intValue();
}
}
@@ -252,20 +264,24 @@ public class TopVoterHandler implements Listener {
e.printStackTrace();
}
if (plugin.getSpecialRewardsConfig().getResetMilestonesMonthly()) {
resetMilestoneCount();
resetGottenMilestones();
}
for (String shopIdent : plugin.getGui().getChestShopIdentifiers()) {
if (plugin.getGui().getChestVoteShopResetMonthly(shopIdent)) {
resetVoteShopLimit(shopIdent);
}
}
resetTotals(TopVoter.Monthly);
if (plugin.getSpecialRewardsConfig().getResetMilestonesMonthly()) {
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
user.setMilestoneCount(0);
user.setHasGottenMilestone(new HashMap<String, Boolean>());
}
}
if (plugin.getStorageType().equals(UserStorage.MYSQL)) {
plugin.getMysql().clearCache();
plugin.getMysql().clearCacheBasic();
}
plugin.getUserManager().getDataManager().clearCache();
long now = ((System.currentTimeMillis() - startTime) / 1000);
plugin.getLogger().info("Finished processing day change, took " + now + " seconds");
}
}
@@ -277,9 +293,13 @@ public class TopVoterHandler implements Listener {
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onWeekChange(WeekChangeEvent event) {
long startTime = System.currentTimeMillis();
synchronized (VotingPluginMain.plugin) {
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(UUID.fromString(uuid), false);
user.dontCache();
user.tempCache();
user.getUserData().updateCacheWithTemp();
if (plugin.getConfigFile().isUseVoteStreaks()) {
if (user.getTotal(TopVoter.Weekly) == 0 && user.getWeekVoteStreak() != 0) {
user.setWeekVoteStreak(0);
@@ -288,22 +308,18 @@ public class TopVoterHandler implements Listener {
|| user.hasPercentageTotal(TopVoter.Weekly,
plugin.getSpecialRewardsConfig().getVoteStreakRequirementWeek(), null)) {
user.addWeekVoteStreak();
plugin.getSpecialRewards().checkVoteStreak(user, "Week");
plugin.getSpecialRewards().checkVoteStreak(user, "Week",
plugin.getBungeeSettings().isUseBungeecoord());
}
}
}
for (String shopIdent : plugin.getGui().getChestShopIdentifiers()) {
if (plugin.getGui().getChestVoteShopResetWeekly(shopIdent)) {
user.setVoteShopIdentifierLimit(shopIdent, 0);
}
}
if (plugin.getConfigFile().isUseHighestTotals()) {
if (user.getHighestWeeklyTotal() < user.getTotal(TopVoter.Weekly)) {
user.setHighestWeeklyTotal(user.getTotal(TopVoter.Weekly));
}
}
user.clearTempCache();
}
if (plugin.getConfigFile().getStoreTopVotersWeekly()) {
@@ -318,12 +334,14 @@ public class TopVoterHandler implements Listener {
int i = 0;
int lastTotal = -1;
@SuppressWarnings("unchecked")
LinkedHashMap<VotingPluginUser, Integer> clone = (LinkedHashMap<VotingPluginUser, Integer>) plugin
.getTopVoter(TopVoter.Weekly).clone();
for (VotingPluginUser user : clone.keySet()) {
LinkedHashMap<TopVoterPlayer, Integer> clone = (LinkedHashMap<TopVoterPlayer, Integer>) plugin
.getTopVoter(TopVoter.Monthly).clone();
for (Entry<TopVoterPlayer, Integer> entry : clone.entrySet()) {
VotingPluginUser user = entry.getKey().getUser();
user.dontCache();
if (!plugin.getConfigFile().getTopVoterIgnorePermission() || !user.isTopVoterIgnore()) {
if (plugin.getConfigFile().getTopVoterAwardsTies()) {
if (user.getTotal(TopVoter.Weekly) != lastTotal) {
if (entry.getValue().intValue() != lastTotal) {
i++;
}
} else {
@@ -333,17 +351,27 @@ public class TopVoterHandler implements Listener {
user.giveWeeklyTopVoterAward(i, places.get(i));
}
}
lastTotal = user.getTotal(TopVoter.Weekly);
lastTotal = entry.getValue().intValue();
}
}
} catch (Exception e) {
e.printStackTrace();
}
for (String shopIdent : plugin.getGui().getChestShopIdentifiers()) {
if (plugin.getGui().getChestVoteShopResetWeekly(shopIdent)) {
resetVoteShopLimit(shopIdent);
}
}
resetTotals(TopVoter.Weekly);
if (plugin.getStorageType().equals(UserStorage.MYSQL)) {
plugin.getMysql().clearCache();
plugin.getMysql().clearCacheBasic();
}
plugin.getUserManager().getDataManager().clearCache();
long now = ((System.currentTimeMillis() - startTime) / 1000);
plugin.getLogger().info("Finished processing day change, took " + now + " seconds");
}
}
@@ -351,29 +379,31 @@ public class TopVoterHandler implements Listener {
plugin.getServer().getPluginManager().registerEvents(this, plugin);
}
public void resetTotals(TopVoter topVoter) {
if (!plugin.getStorageType().equals(UserStorage.MYSQL)) {
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
if (user.getTotal(topVoter) != 0) {
user.resetTotals(topVoter);
}
}
} else {
plugin.getMysql().wipeColumnData(topVoter.getColumnName());
}
public void resetMilestoneCount() {
plugin.getUserManager().removeAllKeyValues("MilestoneCount", DataType.INTEGER);
}
public LinkedHashMap<VotingPluginUser, Integer> sortByValues(
LinkedHashMap<VotingPluginUser, Integer> topVoterAllTime, final boolean order) {
public void resetGottenMilestones() {
plugin.getUserManager().removeAllKeyValues("GottenMileStones", DataType.STRING);
}
List<Entry<VotingPluginUser, Integer>> list = new LinkedList<Entry<VotingPluginUser, Integer>>(
topVoterAllTime.entrySet());
public void resetVoteShopLimit(String shopIdent) {
plugin.getUserManager().removeAllKeyValues("VoteShopLimit" + shopIdent, DataType.INTEGER);
}
public void resetTotals(TopVoter topVoter) {
plugin.getUserManager().removeAllKeyValues(topVoter.getColumnName(), DataType.INTEGER);
}
public LinkedHashMap<TopVoterPlayer, Integer> sortByValues(LinkedHashMap<TopVoterPlayer, Integer> map,
final boolean order) {
List<Entry<TopVoterPlayer, Integer>> list = new LinkedList<Entry<TopVoterPlayer, Integer>>(map.entrySet());
// Sorting the list based on values
Collections.sort(list, new Comparator<Entry<VotingPluginUser, Integer>>() {
Collections.sort(list, new Comparator<Entry<TopVoterPlayer, Integer>>() {
@Override
public int compare(Entry<VotingPluginUser, Integer> o1, Entry<VotingPluginUser, Integer> o2) {
public int compare(Entry<TopVoterPlayer, Integer> o1, Entry<TopVoterPlayer, Integer> o2) {
if (order) {
return o1.getValue().compareTo(o2.getValue());
} else {
@@ -384,8 +414,8 @@ public class TopVoterHandler implements Listener {
});
// Maintaining insertion order with the help of LinkedList
LinkedHashMap<VotingPluginUser, Integer> sortedMap = new LinkedHashMap<VotingPluginUser, Integer>();
for (Entry<VotingPluginUser, Integer> entry : list) {
LinkedHashMap<TopVoterPlayer, Integer> sortedMap = new LinkedHashMap<TopVoterPlayer, Integer>();
for (Entry<TopVoterPlayer, Integer> entry : list) {
sortedMap.put(entry.getKey(), entry.getValue());
}
@@ -409,13 +439,18 @@ public class TopVoterHandler implements Listener {
YMLFileHandler file = new YMLFileHandler(plugin, new File(plugin.getDataFolder(), fileName));
file.setup();
ArrayList<String> topVoters = new ArrayList<String>();
int count = 1;
for (Entry<VotingPluginUser, Integer> entry : plugin.getTopVoter(top).entrySet()) {
topVoters.add(count + ": " + entry.getKey().getPlayerName() + ": " + entry.getValue());
count++;
file.header("Saving top voters for " + top.toString() + ", file also contains other top voter info as backup");
for (TopVoter cTop : TopVoter.values()) {
if (plugin.getTopVoter().containsKey(cTop)) {
ArrayList<String> topVoters = new ArrayList<String>();
int count = 1;
for (Entry<TopVoterPlayer, Integer> entry : plugin.getTopVoter(cTop).entrySet()) {
topVoters.add(count + ": " + entry.getKey().getPlayerName() + ": " + entry.getValue());
count++;
}
file.getData().set(cTop.toString(), topVoters);
}
}
file.getData().set(top.toString(), topVoters);
file.saveData();
}
@@ -430,7 +465,7 @@ public class TopVoterHandler implements Listener {
ArrayList<String> msg = new ArrayList<String>();
ArrayList<String> topVoters = new ArrayList<String>();
int count = 1;
for (Entry<VotingPluginUser, Integer> entry : plugin.getTopVoter(TopVoter.AllTime).entrySet()) {
for (Entry<TopVoterPlayer, Integer> entry : plugin.getTopVoter(TopVoter.AllTime).entrySet()) {
String line = plugin.getConfigFile().getFormatCommandVoteTopLine();
line = line.replace("%num%", "" + count);
line = line.replace("%player%", entry.getKey().getPlayerName());
@@ -469,7 +504,7 @@ public class TopVoterHandler implements Listener {
ArrayList<String> msg = new ArrayList<String>();
ArrayList<String> topVoters = new ArrayList<String>();
int count = 1;
for (Entry<VotingPluginUser, Integer> entry : plugin.getTopVoter(TopVoter.Daily).entrySet()) {
for (Entry<TopVoterPlayer, Integer> entry : plugin.getTopVoter(TopVoter.Daily).entrySet()) {
String line = plugin.getConfigFile().getFormatCommandVoteTopLine();
line = line.replace("%num%", "" + count);
line = line.replace("%player%", entry.getKey().getPlayerName());
@@ -508,7 +543,7 @@ public class TopVoterHandler implements Listener {
ArrayList<String> msg = new ArrayList<String>();
ArrayList<String> topVoters = new ArrayList<String>();
int count = 1;
for (Entry<VotingPluginUser, Integer> entry : plugin.getTopVoter(TopVoter.Monthly).entrySet()) {
for (Entry<TopVoterPlayer, Integer> entry : plugin.getTopVoter(TopVoter.Monthly).entrySet()) {
String line = plugin.getConfigFile().getFormatCommandVoteTopLine();
line = line.replace("%num%", "" + count);
line = line.replace("%player%", entry.getKey().getPlayerName());
@@ -543,10 +578,10 @@ public class TopVoterHandler implements Listener {
*/
public String[] topVotersAllTime() {
ArrayList<String> msg = new ArrayList<String>();
List<Entry<VotingPluginUser, Integer>> list = new LinkedList<Entry<VotingPluginUser, Integer>>(
List<Entry<TopVoterPlayer, Integer>> list = new LinkedList<Entry<TopVoterPlayer, Integer>>(
plugin.getTopVoter(TopVoter.AllTime).entrySet());
int i = 0;
for (Entry<VotingPluginUser, Integer> entry : list) {
for (Entry<TopVoterPlayer, Integer> entry : list) {
String line = "%num%: %player%, %votes%";
line = line.replace("%num%", "" + (i + 1));
try {
@@ -572,7 +607,7 @@ public class TopVoterHandler implements Listener {
public String[] topVotersDaily() {
ArrayList<String> msg = new ArrayList<String>();
ArrayList<VotingPluginUser> users = plugin.convertSet(plugin.getTopVoter(TopVoter.Daily).keySet());
ArrayList<TopVoterPlayer> users = plugin.convertSet(plugin.getTopVoter(TopVoter.Daily).keySet());
for (int i = 0; i < users.size(); i++) {
String line = "%num%: %player%, %votes%";
line = line.replace("%num%", "" + (i + 1));
@@ -596,10 +631,10 @@ public class TopVoterHandler implements Listener {
*/
public String[] topVotersMonthly() {
ArrayList<String> msg = new ArrayList<String>();
List<Entry<VotingPluginUser, Integer>> list = new LinkedList<Entry<VotingPluginUser, Integer>>(
List<Entry<TopVoterPlayer, Integer>> list = new LinkedList<Entry<TopVoterPlayer, Integer>>(
plugin.getTopVoter(TopVoter.Monthly).entrySet());
int i = 0;
for (Entry<VotingPluginUser, Integer> entry : list) {
for (Entry<TopVoterPlayer, Integer> entry : list) {
String line = "%num%: %player%, %votes%";
line = line.replace("%num%", "" + (i + 1));
try {
@@ -628,7 +663,7 @@ public class TopVoterHandler implements Listener {
ArrayList<String> msg = new ArrayList<String>();
ArrayList<String> topVoters = new ArrayList<String>();
int count = 1;
for (Entry<VotingPluginUser, Integer> entry : plugin.getTopVoter(TopVoter.Weekly).entrySet()) {
for (Entry<TopVoterPlayer, Integer> entry : plugin.getTopVoter(TopVoter.Weekly).entrySet()) {
String line = plugin.getConfigFile().getFormatCommandVoteTopLine();
line = line.replace("%num%", "" + count);
line = line.replace("%player%", entry.getKey().getPlayerName());
@@ -656,46 +691,26 @@ public class TopVoterHandler implements Listener {
return ArrayUtils.getInstance().convert(msg);
}
public synchronized void updateTopVoters(ArrayList<VotingPluginUser> users1) {
ArrayList<VotingPluginUser> users = new ArrayList<VotingPluginUser>();
ArrayList<String> blackList = getTopVoterBlackList();
for (VotingPluginUser user : users1) {
if (!blackList.contains(user.getPlayerName())) {
if ((!plugin.getConfigFile().getTopVoterIgnorePermission() || !user.isTopVoterIgnore())
&& !user.isBanned()) {
users.add(user);
}
}
}
public synchronized void updateTopVoters(
LinkedHashMap<TopVoter, LinkedHashMap<TopVoterPlayer, Integer>> tempTopVoter) {
plugin.debug("Number of users to check top voter: " + users.size());
for (TopVoter top : TopVoter.values()) {
if (plugin.getConfigFile().getLoadTopVoter(top)) {
LinkedHashMap<VotingPluginUser, Integer> map = new LinkedHashMap<VotingPluginUser, Integer>();
for (VotingPluginUser user : users) {
int total = user.getTotal(top);
if (total > 0) {
map.put(user, total);
int limitSize = plugin.getConfigFile().getMaxiumNumberOfTopVotersToLoad();
for (Entry<TopVoter, LinkedHashMap<TopVoterPlayer, Integer>> entry : tempTopVoter.entrySet()) {
LinkedHashMap<TopVoterPlayer, Integer> map = entry.getValue();
map = sortByValues(map, false);
if (limitSize > 0) {
ArrayList<TopVoterPlayer> listKeys = new ArrayList<TopVoterPlayer>(map.keySet());
if (listKeys.size() > limitSize) {
for (int i = listKeys.size() - 1; i >= 0 && i >= limitSize; i--) {
map.remove(listKeys.get(i));
}
}
map = sortByValues(map, false);
int limitSize = plugin.getConfigFile().getMaxiumNumberOfTopVotersToLoad();
if (limitSize > 0) {
ArrayList<VotingPluginUser> listKeys = new ArrayList<VotingPluginUser>(map.keySet());
if (listKeys.size() > limitSize) {
for (int i = listKeys.size() - 1; i >= 0 && i >= limitSize; i--) {
map.remove(listKeys.get(i));
}
}
}
plugin.getTopVoter(top).clear();
plugin.getTopVoter().put(top, map);
plugin.debug(top.toString() + " TopVoter loaded");
}
tempTopVoter.put(entry.getKey(), map);
plugin.setTopVoter(tempTopVoter);
plugin.debug(entry.getKey().getName() + " TopVoter loaded, number of players " + map.size());
}
plugin.debug("Updated TopVoter");
@@ -0,0 +1,34 @@
package com.bencodez.votingplugin.topvoter;
import java.util.UUID;
import org.bukkit.inventory.ItemStack;
import com.bencodez.advancedcore.api.misc.PlayerUtils;
import com.bencodez.votingplugin.user.UserManager;
import com.bencodez.votingplugin.user.VotingPluginUser;
import lombok.Getter;
import lombok.Setter;
public class TopVoterPlayer {
@Getter
@Setter
private UUID uuid;
@Getter
@Setter
private String playerName;
public TopVoterPlayer(UUID uuid, String playerName) {
this.uuid = uuid;
this.playerName = playerName;
}
public ItemStack getPlayerHead() {
return PlayerUtils.getInstance().getPlayerSkull(getPlayerName(), false);
}
public VotingPluginUser getUser() {
return UserManager.getInstance().getVotingPluginUser(getUuid(), getPlayerName());
}
}
@@ -39,10 +39,8 @@ public class CheckUpdate {
break;
}
case UPDATE_AVAILABLE: {
plugin.getLogger()
.info(plugin.getName() + " has an update available! Your Version: "
+ plugin.getDescription().getVersion() + " New Version: " + plugin.getUpdater().getVersion()
+ " Use /av download to get the latest update!");
plugin.getLogger().info(plugin.getName() + " has an update available! Your Version: "
+ plugin.getDescription().getVersion() + " New Version: " + plugin.getUpdater().getVersion());
break;
}
default: {
@@ -1,11 +1,14 @@
package com.bencodez.votingplugin.user;
import java.util.ArrayList;
import java.util.UUID;
import org.bukkit.OfflinePlayer;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.user.UUID;
import com.bencodez.advancedcore.api.user.usercache.UserDataManager;
import com.bencodez.advancedcore.api.user.usercache.keys.UserDataKeyInt;
import com.bencodez.advancedcore.api.user.usercache.keys.UserDataKeyString;
import com.bencodez.votingplugin.VotingPluginMain;
public class UserManager {
@@ -24,24 +27,62 @@ public class UserManager {
}
public UserManager() {
super();
}
public void addCachingKeys() {
UserDataManager manager = plugin.getUserManager().getDataManager();
manager.addKey(new UserDataKeyString("TopVoterIgnore").setColumnType("VARCHAR(5)"));
manager.addKey(new UserDataKeyInt("VotePartyVotes"));
manager.addKey(new UserDataKeyString("LastVotes"));
manager.addKey(new UserDataKeyString("CoolDownCheck").setColumnType("VARCHAR(5)"));
manager.addKey(new UserDataKeyString("OfflineVotes").setColumnType("MEDIUMTEXT"));
manager.addKey(new UserDataKeyInt("MilestoneCount"));
manager.addKey(new UserDataKeyInt("MonthTotal"));
manager.addKey(new UserDataKeyInt("AllTimeTotal"));
manager.addKey(new UserDataKeyInt("DailyTotal"));
manager.addKey(new UserDataKeyInt("WeeklyTotal"));
manager.addKey(new UserDataKeyInt("Points"));
manager.addKey(new UserDataKeyInt("DayVoteStreak"));
manager.addKey(new UserDataKeyInt("BestDayVoteStreak"));
manager.addKey(new UserDataKeyString("DayVoteStreakLastUpdate").setColumnType("MEDIUMTEXT"));
manager.addKey(new UserDataKeyString("GottenMileStones").setColumnType("MEDIUMTEXT"));
manager.addKey(new UserDataKeyString("Reminded").setColumnType("VARCHAR(5)"));
manager.addKey(new UserDataKeyString("DisableBroadcast").setColumnType("VARCHAR(5)"));
manager.addKey(new UserDataKeyInt("WeekVoteStreak"));
manager.addKey(new UserDataKeyInt("BestWeekVoteStreak"));
manager.addKey(new UserDataKeyInt("MonthVoteStreak"));
manager.addKey(new UserDataKeyInt("HighestDailyTotal"));
manager.addKey(new UserDataKeyInt("HighestMonthlyTotal"));
manager.addKey(new UserDataKeyInt("HighestWeeklyTotal"));
manager.addKey(new UserDataKeyInt("LastMonthTotal"));
manager.addKey(new UserDataKeyInt("BestMonthVoteStreak"));
if (plugin.getOptions().isPerServerRewards()) {
manager.addKey(new UserDataKeyString("OfflineRewards" + plugin.getOptions().getServer())
.setColumnType("MEDIUMTEXT"));
}
if (plugin.getConfigFile().isExtraAllSitesCheck()) {
manager.addKey(new UserDataKeyInt(getGottenAllSitesDayPath()));
}
}
public String getGottenAllSitesDayPath() {
if (plugin.getBungeeSettings().isUseBungeecoord()) {
return "AllSitesLast_" + plugin.getBungeeSettings().getServerNameStorage();
}
return "AllSitesLast";
}
public ArrayList<String> getAllUUIDs() {
return com.bencodez.advancedcore.api.user.UserManager.getInstance().getAllUUIDs();
return plugin.getUserManager().getAllUUIDs();
}
public VotingPluginUser getVotingPluginUser(com.bencodez.advancedcore.api.user.AdvancedCoreUser user) {
return getVotingPluginUser(java.util.UUID.fromString(user.getUUID()));
}
public VotingPluginUser getVotingPluginUser(java.util.UUID uuid) {
return getVotingPluginUser(new UUID(uuid.toString()));
return new VotingPluginUser(plugin, user);
}
@SuppressWarnings("deprecation")
public VotingPluginUser getVotingPluginUser(java.util.UUID uuid, String playerName) {
return new VotingPluginUser(plugin, new UUID(uuid.toString()), playerName);
public VotingPluginUser getVotingPluginUser(UUID uuid, String playerName) {
return new VotingPluginUser(plugin, uuid, playerName);
}
public VotingPluginUser getVotingPluginUser(OfflinePlayer player) {
@@ -54,12 +95,16 @@ public class UserManager {
@SuppressWarnings("deprecation")
public VotingPluginUser getVotingPluginUser(String playerName) {
return new VotingPluginUser(plugin,
com.bencodez.advancedcore.api.user.UserManager.getInstance().getProperName(playerName));
return new VotingPluginUser(plugin, plugin.getUserManager().getProperName(playerName));
}
@SuppressWarnings("deprecation")
public VotingPluginUser getVotingPluginUser(UUID uuid) {
return new VotingPluginUser(plugin, uuid);
}
@SuppressWarnings("deprecation")
public VotingPluginUser getVotingPluginUser(UUID uuid, boolean loadName) {
return new VotingPluginUser(plugin, uuid, loadName);
}
}
@@ -13,6 +13,7 @@ import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.UUID;
import java.util.stream.Collectors;
import org.bukkit.Bukkit;
@@ -23,15 +24,15 @@ import com.bencodez.advancedcore.api.misc.MiscUtils;
import com.bencodez.advancedcore.api.rewards.RewardBuilder;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import com.bencodez.advancedcore.api.rewards.RewardOptions;
import com.bencodez.advancedcore.api.user.UUID;
import com.bencodez.advancedcore.api.user.AdvancedCoreUser;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.bungee.BungeeMessageData;
import com.bencodez.votingplugin.bungee.BungeeMethod;
import com.bencodez.votingplugin.events.PlayerReceivePointsEvent;
import com.bencodez.votingplugin.events.PlayerVoteCoolDownEndEvent;
import com.bencodez.votingplugin.events.PlayerVoteEvent;
import com.bencodez.votingplugin.objects.VoteSite;
import com.bencodez.votingplugin.topvoter.TopVoter;
import com.bencodez.votingplugin.topvoter.TopVoterPlayer;
// TODO: Auto-generated Javadoc
/**
@@ -60,15 +61,20 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
this.plugin = plugin;
}
@Deprecated
public VotingPluginUser(VotingPluginMain plugin, UUID uuid, boolean loadName) {
super(plugin, uuid, loadName);
this.plugin = plugin;
}
@Deprecated
public VotingPluginUser(VotingPluginMain plugin, UUID uuid, String playerName) {
super(plugin, uuid, playerName);
this.plugin = plugin;
}
@Deprecated
public VotingPluginUser(VotingPluginMain plugin, UUID uuid, boolean loadName) {
super(plugin, uuid, loadName);
public VotingPluginUser(VotingPluginMain plugin, AdvancedCoreUser user) {
super(plugin, user);
this.plugin = plugin;
}
@@ -88,12 +94,6 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
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);
@@ -157,14 +157,17 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
setWeekVoteStreak(getWeekVoteStreak() + 1);
}
public void bungeeVote(String service) {
public void bungeeVote(String service, BungeeMessageData text, boolean setTotals) {
if (plugin.getBungeeSettings().isUseBungeecoord()) {
VotingPluginMain.plugin.debug("Bungee vote for " + getPlayerName() + " on " + service);
PlayerVoteEvent voteEvent = new PlayerVoteEvent(plugin.getVoteSite(service), getPlayerName(), service,
PlayerVoteEvent voteEvent = new PlayerVoteEvent(plugin.getVoteSite(service, true), getPlayerName(), service,
true);
voteEvent.setBungee(true);
voteEvent.setForceBungee(true);
voteEvent.setAddTotals(setTotals);
voteEvent.setBungeeTextTotals(text);
voteEvent.setVotingPluginUser(this);
Bukkit.getScheduler().runTaskAsynchronously(plugin, new Runnable() {
@Override
@@ -175,14 +178,17 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
}
}
public void bungeeVoteOnline(String service) {
public void bungeeVoteOnline(String service, BungeeMessageData text, boolean setTotals) {
if (plugin.getBungeeSettings().isUseBungeecoord()) {
VotingPluginMain.plugin.debug("Bungee online vote for " + getPlayerName() + " on " + service);
PlayerVoteEvent voteEvent = new PlayerVoteEvent(plugin.getVoteSite(service), getPlayerName(), service,
PlayerVoteEvent voteEvent = new PlayerVoteEvent(plugin.getVoteSite(service, true), getPlayerName(), service,
true);
voteEvent.setBungee(true);
voteEvent.setForceBungee(false);
voteEvent.setForceBungee(true);
voteEvent.setAddTotals(setTotals);
voteEvent.setBungeeTextTotals(text);
voteEvent.setVotingPluginUser(this);
Bukkit.getScheduler().runTaskAsynchronously(plugin, new Runnable() {
@Override
@@ -193,18 +199,20 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
}
}
public void bungeeVotePluginMessaging(String service, long time, BungeeMessageData text) {
public void bungeeVotePluginMessaging(String service, long time, BungeeMessageData text, boolean setTotals,
boolean wasOnline) {
if (plugin.getBungeeSettings().isUseBungeecoord()) {
VotingPluginMain.plugin.debug("Pluginmessaging vote for " + getPlayerName() + " on " + service);
PlayerVoteEvent voteEvent = new PlayerVoteEvent(plugin.getVoteSite(service), getPlayerName(), service,
PlayerVoteEvent voteEvent = new PlayerVoteEvent(plugin.getVoteSite(service, true), getPlayerName(), service,
true);
voteEvent.setBungee(true);
voteEvent.setVotingPluginUser(this);
voteEvent.setForceBungee(true);
voteEvent.setTime(time);
voteEvent.setAddTotals(false);
voteEvent.setAddTotals(setTotals);
voteEvent.setBungeeTextTotals(text);
voteEvent.setWasOnline(wasOnline);
Bukkit.getScheduler().runTaskAsynchronously(plugin, new Runnable() {
@Override
@@ -222,9 +230,11 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
*/
public boolean canVoteAll() {
for (VoteSite voteSite : plugin.getVoteSites()) {
boolean canVote = canVoteSite(voteSite);
if (!canVote) {
return false;
if (!voteSite.isHidden()) {
boolean canVote = canVoteSite(voteSite);
if (!canVote) {
return false;
}
}
}
return true;
@@ -232,9 +242,11 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
public boolean canVoteAny() {
for (VoteSite voteSite : plugin.getVoteSites()) {
boolean canVote = canVoteSite(voteSite);
if (canVote) {
return true;
if (!voteSite.isIgnoreCanVote() && !voteSite.isHidden()) {
boolean canVote = canVoteSite(voteSite);
if (canVote) {
return true;
}
}
}
return false;
@@ -259,13 +271,13 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
if (!voteSite.isVoteDelayDaily()) {
double votedelay = voteSite.getVoteDelay();
double voteDelayMin = voteSite.getVoteDelayMin();
if (votedelay == 0) {
if (votedelay == 0 && voteDelayMin == 0) {
return false;
}
LocalDateTime nextvote = lastVote.plusHours((long) votedelay)
.plusMinutes((long) voteSite.getVoteDelayMin());
LocalDateTime nextvote = lastVote.plusHours((long) votedelay).plusMinutes((long) voteDelayMin);
return now.isAfter(nextvote);
} else {
@@ -319,32 +331,20 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
return true;
}
public void checkCoolDownEvents() {
for (VoteSite site : plugin.getVoteSites()) {
if (canVoteSite(site) != getLastCoolDownCheck(site)) {
plugin.debug(getPlayerName() + " vote cooldown ended: " + site.getKey());
PlayerVoteCoolDownEndEvent event = new PlayerVoteCoolDownEndEvent(this, site);
plugin.getServer().getPluginManager().callEvent(event);
setLastVoteCoolDownCheck(true, site);
}
}
}
public void checkDayVoteStreak() {
public void checkDayVoteStreak(boolean forceBungee) {
if (!voteStreakUpdatedToday(LocalDateTime.now())) {
if (!plugin.getSpecialRewardsConfig().isVoteStreakRequirementUsePercentage() || hasPercentageTotal(
TopVoter.Daily, plugin.getSpecialRewardsConfig().getVoteStreakRequirementDay(), null)) {
addDayVoteStreak();
plugin.getSpecialRewards().checkVoteStreak(this, "Day");
plugin.getSpecialRewards().checkVoteStreak(this, "Day", forceBungee);
setDayVoteStreakLastUpdate(System.currentTimeMillis());
}
}
}
public void clearOfflineRewards() {
public void clearOfflineVotes() {
setOfflineVotes(new ArrayList<String>());
setOfflineRewards(new ArrayList<String>());
setOfflineOtherRewards(new ArrayList<String>());
}
public void clearTotals() {
@@ -355,40 +355,44 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
@Deprecated
public int getAllTimeTotal() {
return getUserData().getInt("AllTimeTotal");
return getUserData().getInt("AllTimeTotal", isCacheData(), isWaitForCache());
}
public int getBestDayVoteStreak() {
return getData().getInt("BestDayVoteStreak", isWaitForCache());
return getData().getInt("BestDayVoteStreak", isCacheData(), isWaitForCache());
}
public int getBestMonthVoteStreak() {
return getData().getInt("BestMonthVoteStreak", isWaitForCache());
return getData().getInt("BestMonthVoteStreak", isCacheData(), isWaitForCache());
}
public int getBestWeekVoteStreak() {
return getData().getInt("BestWeekVoteStreak", isWaitForCache());
return getData().getInt("BestWeekVoteStreak", isCacheData(), isWaitForCache());
}
@Deprecated
public int getDailyTotal() {
return getUserData().getInt("DailyTotal", isWaitForCache());
return getUserData().getInt("DailyTotal", isCacheData(), isWaitForCache());
}
public int getDayVoteStreak() {
return getData().getInt("DayVoteStreak", isWaitForCache());
return getData().getInt("DayVoteStreak", isCacheData(), isWaitForCache());
}
public long getDayVoteStreakLastUpdate() {
String str = getData().getString("DayVoteStreakLastUpdate", isWaitForCache());
if (str.isEmpty()) {
String str = getData().getString("DayVoteStreakLastUpdate", isCacheData(), isWaitForCache());
if (str == null || str.isEmpty() || str.equals("null")) {
return 0;
}
return Long.parseLong(str);
}
public boolean getDisableBroadcast() {
return getUserData().getBoolean("DisableBroadcast");
return getUserData().getBoolean("DisableBroadcast", isCacheData(), isWaitForCache());
}
public int getGottenAllSitesDay() {
return getData().getInt(plugin.getVotingPluginUserManager().getGottenAllSitesDayPath(), 0, isWaitForCache());
}
public HashMap<String, Boolean> getHasGottenMilestone() {
@@ -405,48 +409,19 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
}
public int getHighestDailyTotal() {
return getData().getInt("HighestDailyTotal", isWaitForCache());
return getData().getInt("HighestDailyTotal", isCacheData(), isWaitForCache());
}
public int getHighestMonthlyTotal() {
return getData().getInt("HighestMonthlyTotal", isWaitForCache());
return getData().getInt("HighestMonthlyTotal", isCacheData(), isWaitForCache());
}
public int getHighestWeeklyTotal() {
return getData().getInt("HighestWeeklyTotal", isWaitForCache());
}
public boolean getLastCoolDownCheck(VoteSite site) {
HashMap<VoteSite, Boolean> array = getLastCoolDownCheckArray();
if (array.containsKey(site)) {
return array.get(site).booleanValue();
}
return true;
}
public HashMap<VoteSite, Boolean> getLastCoolDownCheckArray() {
HashMap<VoteSite, Boolean> lastVotesCheck = new HashMap<VoteSite, Boolean>();
ArrayList<String> LastVotesCheckList = getUserData().getStringList("LastVoteCoolDownCheck");
for (String str : LastVotesCheckList) {
String[] data = str.split("//");
if (data.length > 1 && plugin.hasVoteSite(data[0])) {
VoteSite site = plugin.getVoteSite(data[0]);
if (site != null) {
Boolean value = Boolean.FALSE;
try {
value = Boolean.valueOf(data[1]);
} catch (NumberFormatException e) {
plugin.debug("Not value: " + data[1]);
}
lastVotesCheck.put(site, value);
}
}
}
return lastVotesCheck;
return getData().getInt("HighestWeeklyTotal", isCacheData(), isWaitForCache());
}
public int getLastMonthTotal() {
return getData().getInt("LastMonthTotal", isWaitForCache());
return getData().getInt("LastMonthTotal", isCacheData(), isWaitForCache());
}
public HashMap<VoteSite, Long> getLastVotes() {
@@ -455,7 +430,7 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
for (String str : LastVotesList) {
String[] data = str.split("//");
if (data.length > 1 && plugin.hasVoteSite(data[0])) {
VoteSite site = plugin.getVoteSite(data[0]);
VoteSite site = plugin.getVoteSite(data[0], true);
if (site != null) {
long time = 0;
try {
@@ -489,24 +464,20 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
}
public int getMilestoneCount() {
return getData().getInt("MilestoneCount", getAllTimeTotal(), isWaitForCache());
return getData().getInt("MilestoneCount", getAllTimeTotal(), isCacheData(), isWaitForCache());
}
@Deprecated
public int getMonthTotal() {
return getData().getInt("MonthTotal");
return getData().getInt("MonthTotal", isCacheData(), isWaitForCache());
}
public int getMonthVoteStreak() {
return getData().getInt("MonthVoteStreak", isWaitForCache());
}
public ArrayList<String> getOfflineOtherRewards() {
return getUserData().getStringList("OfflineOtherRewards");
return getData().getInt("MonthVoteStreak", isCacheData(), isWaitForCache());
}
public ArrayList<String> getOfflineVotes() {
return getUserData().getStringList("OfflineVotes");
return getUserData().getStringList("OfflineVotes", isCacheData(), isWaitForCache());
}
/**
@@ -515,11 +486,19 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
* @return the points
*/
public int getPoints() {
return getUserData().getInt("Points", isWaitForCache());
return getUserData().getInt(getPointsPath(), isCacheData(), isWaitForCache());
}
public String getPointsPath() {
if (plugin.getBungeeSettings().isPerServerPoints()) {
return plugin.getBungeeSettings().getServerNameStorage() + "_Points";
} else {
return "Points";
}
}
public java.util.UUID getPrimaryAccount() {
String s = getData().getString("PrimaryAccount", true);
String s = getData().getString("PrimaryAccount", isCacheData(), isWaitForCache());
if (s != null && !s.isEmpty()) {
return java.util.UUID.fromString(s);
}
@@ -553,13 +532,13 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
public int getTotal(TopVoter top) {
switch (top) {
case AllTime:
return getUserData().getInt("AllTimeTotal", isWaitForCache());
return getUserData().getInt("AllTimeTotal", isCacheData(), isWaitForCache());
case Daily:
return getUserData().getInt("DailyTotal", isWaitForCache());
return getUserData().getInt("DailyTotal", isCacheData(), isWaitForCache());
case Monthly:
return getData().getInt("MonthTotal", isWaitForCache());
return getData().getInt("MonthTotal", isCacheData(), isWaitForCache());
case Weekly:
return getUserData().getInt("WeeklyTotal", isWaitForCache());
return getUserData().getInt("WeeklyTotal", isCacheData(), isWaitForCache());
default:
break;
}
@@ -567,20 +546,20 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
}
public int getVotePartyVotes() {
return getUserData().getInt("VotePartyVotes", isWaitForCache());
return getUserData().getInt("VotePartyVotes", isCacheData(), isWaitForCache());
}
public int getVoteShopIdentifierLimit(String identifier) {
return getData().getInt("VoteShopLimit" + identifier, isWaitForCache());
return getData().getInt("VoteShopLimit" + identifier, isCacheData(), isWaitForCache());
}
@Deprecated
public int getWeeklyTotal() {
return getUserData().getInt("WeeklyTotal");
return getUserData().getInt("WeeklyTotal", isCacheData(), isWaitForCache());
}
public int getWeekVoteStreak() {
return getData().getInt("WeekVoteStreak", isWaitForCache());
return getData().getInt("WeekVoteStreak", isCacheData(), isWaitForCache());
}
public void giveDailyTopVoterAward(int place, String path) {
@@ -618,57 +597,6 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
.withPlaceHolder("votes", "" + getTotal(TopVoter.Monthly)).setOnline(isOnline()).send(this);
}
public void giveOfflineOtherRewards() {
// old reward api, will be removed in the future
ArrayList<String> offlineRewards = getOfflineOtherRewards();
for (String str : offlineRewards) {
if (str.equalsIgnoreCase("FirstVote")) {
plugin.getSpecialRewards().giveFirstVoteRewards(this, false);
} else if (str.equalsIgnoreCase("AllSites")) {
plugin.getSpecialRewards().giveAllSitesRewards(this, false);
} else if (str.equalsIgnoreCase("VoteParty")) {
plugin.getVoteParty().giveReward(this, false);
} else if (str.contains("Cumulative")) {
String st = str.substring("Cumulative".length());
if (StringParser.getInstance().isInt(st)) {
int votesRequired = Integer.parseInt(st);
if (votesRequired != 0) {
if (plugin.getSpecialRewardsConfig().getCumulativeRewardEnabled(votesRequired)) {
plugin.getSpecialRewards().giveCumulativeVoteReward(this, false, votesRequired);
}
}
}
} else if (str.contains("MileStone")) {
String st = str.substring("MileStone".length());
if (StringParser.getInstance().isInt(st)) {
int votesRequired = Integer.parseInt(st);
if (votesRequired > 0) {
if (plugin.getSpecialRewardsConfig().getMilestoneRewardEnabled(votesRequired)) {
plugin.getSpecialRewards().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 (plugin.getSpecialRewardsConfig().getVoteStreakRewardEnabled(type, st)) {
plugin.getSpecialRewards().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(plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getWeeklyAwardRewardsPath(path)).withPlaceHolder("place", "" + place)
@@ -689,6 +617,14 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
return getTotal(TopVoter.AllTime) != 0;
}
public boolean hasGottenFirstVoteToday() {
if (plugin.getBungeeSettings().isUseBungeecoord()
&& plugin.getBungeeHandler().getMethod().equals(BungeeMethod.PLUGINMESSAGING)) {
return getTotal(TopVoter.Daily) > 1;
}
return getTotal(TopVoter.Daily) != 0;
}
/**
* Checks for gotten milestone.
*
@@ -755,9 +691,10 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
return;
}
VotingPluginMain.plugin.extraDebug("Checking offline vote site votes");
Player player = getPlayer();
if (player != null) {
VotingPluginMain.plugin.extraDebug("Checking offline vote site votes for " + player.getName());
boolean topVoterIngorePerm = player.hasPermission("VotingPlugin.TopVoter.Ignore");
if (isTopVoterIgnore() != topVoterIngorePerm) {
setTopVoterIgnore(topVoterIngorePerm);
@@ -765,20 +702,18 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
ArrayList<String> offlineVotes = getOfflineVotes();
// plugin.debug(ArrayUtils.getInstance().makeStringList(offlineVotes));
if (offlineVotes.size() > 0) {
sendVoteEffects(true);
sendVoteEffects(false);
setOfflineVotes(new ArrayList<String>());
}
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, false);
playerVote(plugin.getVoteSite(offlineVotes.get(i), true), false, true, false);
} else {
plugin.debug("Site doesn't exist: " + offlineVotes.get(i));
}
}
giveOfflineOtherRewards();
}
}
@@ -855,6 +790,10 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
getUserData().setBoolean("DisableBroadcast", value);
}
public void setGottenAllSitesDay(int day) {
getData().setInt(plugin.getVotingPluginUserManager().getGottenAllSitesDayPath(), day);
}
public void setHasGotteMilestone(int votesRequired, boolean b) {
HashMap<String, Boolean> hasGottenMilestone = getHasGottenMilestone();
hasGottenMilestone.put("" + votesRequired, b);
@@ -882,25 +821,10 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
getData().setInt("HighestWeeklyTotal", total);
}
public void setLastCoolDownCheckArray(HashMap<VoteSite, Boolean> lastVotesCheck) {
ArrayList<String> data = new ArrayList<String>();
for (Entry<VoteSite, Boolean> entry : lastVotesCheck.entrySet()) {
String str = entry.getKey().getKey() + "//" + entry.getValue().booleanValue();
data.add(str);
}
getUserData().setStringList("LastVoteCoolDownCheck", data);
}
public void setLastMonthTotal(int total) {
getData().setInt("LastMonthTotal", total);
}
public void setLastVoteCoolDownCheck(boolean lastDelay, VoteSite voteSite) {
HashMap<VoteSite, Boolean> array = getLastCoolDownCheckArray();
array.put(voteSite, Boolean.valueOf(lastDelay));
setLastCoolDownCheckArray(array);
}
public void setLastVotes(HashMap<VoteSite, Long> lastVotes) {
ArrayList<String> data = new ArrayList<String>();
for (Entry<VoteSite, Long> entry : lastVotes.entrySet()) {
@@ -914,6 +838,22 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
getData().setInt("MilestoneCount", value);
}
public String getCoolDownCheckPath() {
if (plugin.getBungeeSettings().isUseBungeecoord()) {
return "CoolDownCheck_" + plugin.getBungeeSettings().getServer();
} else {
return "CoolDownCheck";
}
}
public void setCoolDownCheck(boolean coolDownCheck) {
getData().setBoolean(getCoolDownCheckPath(), coolDownCheck);
}
public boolean getCoolDownCheck() {
return getData().getBoolean(getCoolDownCheckPath(), isCacheData(), isWaitForCache());
}
@Deprecated
public void setMonthTotal(int total) {
setTotal(TopVoter.Monthly, total);
@@ -926,10 +866,6 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
}
}
public void setOfflineOtherRewards(ArrayList<String> offlineOtherRewards) {
getUserData().setStringList("OfflineOtherRewards", offlineOtherRewards);
}
public void setOfflineVotes(ArrayList<String> offlineVotes) {
getUserData().setStringList("OfflineVotes", offlineVotes);
}
@@ -940,7 +876,7 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
* @param value the new points
*/
public void setPoints(int value) {
getUserData().setInt("Points", value, !plugin.getBungeeSettings().isUseBungeecoord());
getUserData().setInt(getPointsPath(), value, !plugin.getBungeeSettings().isUseBungeecoord());
}
public void setPrimaryAccount(java.util.UUID uuid) {
@@ -1113,6 +1049,18 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
return plugin.getConfigFile().getFormatCommandsVoteLastNeverVoted();
}
public String voteCommandLastGUILine(VoteSite voteSite) {
String timeString = voteCommandLastDate(voteSite);
String timeSince = voteCommandLastDuration(voteSite);
HashMap<String, String> placeholders = new HashMap<String, String>();
placeholders.put("time", timeString);
placeholders.put("SiteName", voteSite.getDisplayName());
placeholders.put("timesince", timeSince);
return StringParser.getInstance().replacePlaceHolder(plugin.getGui().getChestVoteLastLine(), placeholders);
}
public String voteCommandLastLine(VoteSite voteSite) {
String timeString = voteCommandLastDate(voteSite);
String timeSince = voteCommandLastDuration(voteSite);
@@ -1131,7 +1079,7 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
long time = getTime(voteSite);
LocalDateTime now = plugin.getTimeChecker().getTime();
;
LocalDateTime lastVote = LocalDateTime.ofInstant(Instant.ofEpochMilli(time), ZoneId.systemDefault())
.plusHours(VotingPluginMain.plugin.getOptions().getTimeHourOffSet());
@@ -1228,7 +1176,7 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
public long voteNextDurationTime(VoteSite voteSite) {
long time = getTime(voteSite);
LocalDateTime now = plugin.getTimeChecker().getTime();
;
LocalDateTime lastVote = LocalDateTime.ofInstant(Instant.ofEpochMilli(time), ZoneId.systemDefault())
.plusHours(VotingPluginMain.plugin.getOptions().getTimeHourOffSet());
@@ -1277,4 +1225,32 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
return MiscUtils.getInstance().getTime(getDayVoteStreakLastUpdate()).getDayOfYear() == time.getDayOfYear();
}
public int getSitesNotVotedOn() {
int amount = 0;
for (VoteSite site : plugin.getVoteSites()) {
if (!site.isHidden()) {
if (canVoteSite(site)) {
amount++;
}
}
}
return amount;
}
public TopVoterPlayer getTopVoterPlayer() {
return new TopVoterPlayer(UUID.fromString(getUUID()), getPlayerName());
}
public long getNextTimeAllSitesAvailable() {
long longest = 0;
for (VoteSite site : plugin.getVoteSites()) {
long seconds = voteNextDurationTime(site);
if (seconds > longest) {
longest = seconds;
}
}
return longest;
}
}
@@ -3,6 +3,7 @@ package com.bencodez.votingplugin.voteparty;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.UUID;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
@@ -16,7 +17,7 @@ import com.bencodez.advancedcore.api.rewards.RewardBuilder;
import com.bencodez.advancedcore.api.time.events.DayChangeEvent;
import com.bencodez.advancedcore.api.time.events.MonthChangeEvent;
import com.bencodez.advancedcore.api.time.events.WeekChangeEvent;
import com.bencodez.advancedcore.api.user.UUID;
import com.bencodez.advancedcore.api.user.userstorage.DataType;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.events.VotePartyEvent;
import com.bencodez.votingplugin.user.UserManager;
@@ -56,10 +57,7 @@ public class VoteParty implements Listener {
}
}
/**
* Check.
*/
public void check() {
public void check(boolean forceBungee) {
if (getTotalVotes() >= getVotesRequired() && ((plugin.getSpecialRewardsConfig().getVotePartyOnlyOncePerDay()
&& plugin.getServerData().isLastVotePartySameDay())
|| !plugin.getSpecialRewardsConfig().getVotePartyOnlyOncePerDay())) {
@@ -72,8 +70,8 @@ public class VoteParty implements Listener {
if (event.isCancelled()) {
return;
}
MiscUtils.getInstance().broadcast(plugin.getSpecialRewardsConfig().getVotePartyBroadcast());
giveRewards();
giveRewards(forceBungee);
if (plugin.getSpecialRewardsConfig().getVotePartyIncreaseVotesRquired() > 0) {
plugin.getServerData().setVotePartyExtraRequired(plugin.getServerData().getVotePartyExtraRequired()
@@ -153,27 +151,27 @@ public class VoteParty implements Listener {
return required;
}
public void giveReward(VotingPluginUser user) {
public void giveReward(VotingPluginUser user, boolean useBungee) {
if (plugin.getSpecialRewardsConfig().getVotePartyUserVotesRequired() > 0) {
if (user.getVotePartyVotes() < plugin.getSpecialRewardsConfig().getVotePartyUserVotesRequired()) {
return;
}
}
giveReward(user, user.isOnline());
giveReward(user, user.isOnline(), useBungee);
}
public void giveReward(VotingPluginUser user, boolean online) {
public void giveReward(VotingPluginUser user, boolean online, boolean useBungee) {
new RewardBuilder(plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getVotePartyRewardsPath()).setOnline(online)
plugin.getSpecialRewardsConfig().getVotePartyRewardsPath())
.setOnline(online)
.withPlaceHolder("VotesRequired",
"" + plugin.getSpecialRewardsConfig().getVotePartyVotesRequired())
.send(user);
.setServer(useBungee).send(user);
}
/**
* Give rewards.
*/
public void giveRewards() {
public void giveRewards(boolean forceBungee) {
MiscUtils.getInstance().broadcast(plugin.getSpecialRewardsConfig().getVotePartyBroadcast());
for (final String cmd : plugin.getSpecialRewardsConfig().getVotePartyCommands()) {
Bukkit.getScheduler().runTask(plugin, new Runnable() {
@@ -188,15 +186,23 @@ public class VoteParty implements Listener {
if (plugin.getSpecialRewardsConfig().getVotePartyGiveAllPlayers()) {
plugin.debug("Trying to give all players vote party");
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
giveReward(user);
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(UUID.fromString(uuid));
user.dontCache();
if (!plugin.getSpecialRewardsConfig().isVotePartyGiveOnlinePlayersOnly() || user.isOnline()) {
giveReward(user, forceBungee);
}
}
} else {
plugin.debug("Trying to give all online players vote party");
plugin.debug("Trying to give all voted players vote party");
plugin.debug(ArrayUtils.getInstance().makeStringList(getVotedUsers()));
for (String uuid : getVotedUsers()) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
giveReward(user);
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(UUID.fromString(uuid));
user.dontCache();
if (!plugin.getSpecialRewardsConfig().isVotePartyGiveOnlinePlayersOnly() || user.isOnline()) {
giveReward(user, forceBungee);
}
}
}
reset(false);
@@ -209,13 +215,6 @@ public class VoteParty implements Listener {
}
}
@EventHandler
public void onWeekChange(WeekChangeEvent event) {
if (plugin.getSpecialRewardsConfig().getVotePartyResetWeekly()) {
reset(true);
}
}
@EventHandler
public void onMonthChange(MonthChangeEvent event) {
if (plugin.getSpecialRewardsConfig().getVotePartyResetMontly()) {
@@ -227,21 +226,27 @@ public class VoteParty implements Listener {
}
}
@EventHandler
public void onWeekChange(WeekChangeEvent event) {
if (plugin.getSpecialRewardsConfig().getVotePartyResetWeekly()) {
reset(true);
}
}
public void register() {
plugin.getServer().getPluginManager().registerEvents(this, plugin);
}
public void resetVotePartyCount() {
plugin.getUserManager().removeAllKeyValues("VotePartyVotes", DataType.INTEGER);
}
public void reset(boolean override) {
if (override) {
setTotalVotes(0);
}
setVotedUsers(new ArrayList<String>());
for (String uuid : UserManager.getInstance().getAllUUIDs()) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
if (user.getVotePartyVotes() != 0) {
user.setVotePartyVotes(0);
}
}
resetVotePartyCount();
}
@@ -265,13 +270,13 @@ public class VoteParty implements Listener {
plugin.getServerData().saveData();
}
public synchronized void vote(VotingPluginUser user, boolean realVote) {
public synchronized void vote(VotingPluginUser user, boolean realVote, boolean forceBungee) {
if (plugin.getSpecialRewardsConfig().getVotePartyEnabled()) {
if (plugin.getSpecialRewardsConfig().getVotePartyCountFakeVotes() || realVote) {
if (plugin.getSpecialRewardsConfig().getVotePartyCountOfflineVotes() || user.isOnline()) {
addTotal(user);
addVotePlayer(user);
check();
check(forceBungee);
}
}
}
@@ -1,9 +1,11 @@
package com.bencodez.votingplugin.votereminding;
import java.util.Timer;
import java.util.TimerTask;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.misc.PlayerUtils;
import com.bencodez.advancedcore.api.rewards.RewardBuilder;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.user.UserManager;
@@ -18,6 +20,8 @@ public class VoteReminding {
/** The plugin. */
private VotingPluginMain plugin;
private Timer timer;
public VoteReminding(VotingPluginMain plugin) {
this.plugin = plugin;
}
@@ -28,22 +32,13 @@ public class VoteReminding {
* @param user the user
*/
public void checkRemind(VotingPluginUser user) {
String playerName = user.getPlayerName();
if (PlayerUtils.getInstance().hasServerPermission(playerName, "VotingPlugin.Login.RemindVotes")
|| PlayerUtils.getInstance().hasServerPermission(playerName, "VotingPlugin.Player")) {
if (user.canVoteAll() || (user.canVoteAny() && user.hasPermission("VotingPlugin.Login.RemindVotes.Any"))) {
Player player = Bukkit.getPlayer(playerName);
if (player != null) {
if (!plugin.getConfigFile().getVoteRemindingRemindOnlyOnce()) {
runRemind(user);
user.setReminded(true);
} else if (!user.isReminded()) {
runRemind(user);
user.setReminded(true);
}
if (user.hasPermission("VotingPlugin.Login.RemindVotes") || user.hasPermission("VotingPlugin.Player")) {
if (shouldRemind(user)) {
if (!plugin.getConfigFile().getVoteRemindingRemindOnlyOnce()) {
runRemind(user);
} else if (!user.isReminded()) {
runRemind(user);
}
}
}
@@ -51,23 +46,33 @@ public class VoteReminding {
private void giveReward(VotingPluginUser user) {
new RewardBuilder(plugin.getConfigFile().getData(), plugin.getConfigFile().getVoteRemindingRewardsPath())
.setGiveOffline(false).send(user);
.withPlaceHolder("sitesavailable", "" + user.getSitesNotVotedOn()).setGiveOffline(false).send(user);
}
/**
* Load remind checking.
*/
public void loadRemindChecking() {
Bukkit.getScheduler().runTaskTimerAsynchronously(plugin, new Runnable() {
if (timer != null) {
timer.cancel();
}
if (plugin.getConfigFile().getVoteRemindingRemindDelay() > 0) {
timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
for (Player player : Bukkit.getServer().getOnlinePlayers()) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(player);
checkRemind(user);
@Override
public void run() {
if (plugin != null) {
for (Player player : Bukkit.getServer().getOnlinePlayers()) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(player);
checkRemind(user);
}
} else {
cancel();
}
}
}
}, 10, plugin.getConfigFile().getVoteRemindingRemindDelay() * 20 * 60);
}, 1000 * 30, plugin.getConfigFile().getVoteRemindingRemindDelay() * 1000 * 60);
}
}
/**
@@ -80,30 +85,42 @@ public class VoteReminding {
if (plugin.getConfigFile().isUsePrimaryAccountForPlaceholders() && user.hasPrimaryAccount()) {
user = UserManager.getInstance().getVotingPluginUser(user.getPrimaryAccount());
}
if (user.canVoteAll() && user.shouldBeReminded()) {
giveReward(user);
if (user.getData().hasData() && plugin.getConfigFile().getVoteRemindingRemindOnlyOnce()) {
user.setReminded(true);
giveReward(user);
plugin.debug(user.getPlayerName() + " was reminded!");
}
plugin.debug(user.getPlayerName() + " was reminded!");
}
}
public boolean shouldRemind(VotingPluginUser user) {
if (user.shouldBeReminded()) {
boolean hasPermAll = user.hasPermission("VotingPlugin.Login.RemindVotes.All");
if (hasPermAll) {
return user.canVoteAll();
} else {
return user.canVoteAny();
}
} else {
return false;
}
}
public void runRemindLogin(VotingPluginUser user) {
if (plugin.getConfigFile().getVoteRemindingEnabled()) {
if (plugin.getConfigFile().isUsePrimaryAccountForPlaceholders() && user.hasPrimaryAccount()) {
user = UserManager.getInstance().getVotingPluginUser(user.getPrimaryAccount());
}
if ((!UserManager.getInstance().getAllUUIDs().contains(user.getUUID()) || (user.canVoteAll()
|| (user.canVoteAny() && user.hasPermission("VotingPlugin.Login.RemindVotes.Any"))))
&& user.shouldBeReminded()) {
giveReward(user);
if (user.getData().hasData()) {
user.setReminded(true);
if (user.hasPermission("VotingPlugin.Login.RemindVotes") || user.hasPermission("VotingPlugin.Player")) {
if (plugin.getConfigFile().isUsePrimaryAccountForPlaceholders() && user.hasPrimaryAccount()) {
user = UserManager.getInstance().getVotingPluginUser(user.getPrimaryAccount());
}
plugin.debug(user.getPlayerName() + " was reminded!");
if ((!UserManager.getInstance().getAllUUIDs().contains(user.getUUID()) || shouldRemind(user))) {
giveReward(user);
if (user.getData().hasData()) {
user.setReminded(true);
}
plugin.debug(user.getPlayerName() + " was reminded!");
}
}
}
}