Compare commits

..
508 Commits
Author SHA1 Message Date
BenCodez 2e17b3defd Update version number to 6.12.1 2023-04-17 17:05:28 -04:00
BenCodez 76dbfb8fdf Fixed issues with uppercase placeholders 2023-04-17 17:04:31 -04:00
BenCodez 8fd206b119 Fixed missing column types for mysql 2023-04-15 20:27:14 -04:00
BenCodez 9c6e514234 Update version number to 6.12 2023-04-15 20:09:36 -04:00
BenCodez eb66ccb90d Fix auto caching placeholders not saving for restarts 2023-04-15 20:07:30 -04:00
BenCodez c004dc6106 Fixed trying to cache invalid placeholders 2023-04-15 19:49:09 -04:00
BenCodez f54ccbd7b2 Improve config some more 2023-04-15 19:35:39 -04:00
BenCodez 8cdd0b713b More optimizations on time changes 2023-04-10 19:34:05 -04:00
BenCodez 2562e749db Optimize time change events even more 2023-04-10 17:49:29 -04:00
BenCodez 1a1e5d84bb Improve time change events performance if settings are disabled 2023-04-10 17:44:15 -04:00
BenCodez d4d23035e3 Update pom.xml 2023-04-07 16:46:56 -04:00
BenCodez 5e334e4a8a Update pom.xml 2023-04-07 16:45:16 -04:00
Ben 22991efccf Delete jitpack.yml 2023-04-07 16:39:51 -04:00
Ben 5341fbc3ba Update README.md 2023-04-07 16:09:53 -04:00
BenCodez 2e0fbd01e6 Check for vanish on vote reminding 2023-04-05 16:44:57 -04:00
BenCodez d1d395d9b3 Reformat config to improve overall look 2023-04-04 19:43:02 -04:00
BenCodez 9aeedac2ad Extra check on background task to make sure plugin is enabled 2023-04-02 19:36:56 -04:00
BenCodez 265ed68e0f Add extra check on background task if plugin is enabled 2023-04-01 15:37:04 -04:00
BenCodez b73daaf917 Improve /vote total all command speeds 2023-04-01 15:36:01 -04:00
BenCodez 39d8e414f4 Fix error on shutdown 2023-03-31 16:58:48 -04:00
BenCodez 693541dd00 Add support for extra items on other GUI's 2023-03-30 20:27:05 -04:00
BenCodez 5dce8031c5 More changes to placeholder caching 2023-03-29 17:32:37 -04:00
BenCodez babef8ccf3 Changes to placeholder caching 2023-03-29 17:10:01 -04:00
BenCodez 7a881206ca Change name of vote party one time commands option to avoid confusion 2023-03-28 19:42:52 -04:00
BenCodez aed8ecca26 Fix command help messages being wrong 2023-03-28 19:15:46 -04:00
BenCodez 25dab3157a Add improved placeholder controls 2023-03-27 20:28:54 -04:00
BenCodez 81d8b535ee Adjust caching setting 2023-03-26 17:47:01 -04:00
BenCodez c94802a141 Add global vote party bungee commands reward and edit commands 2023-03-25 19:56:18 -04:00
BenCodez 85e31f8292 Add config option to always use cache for placeholders - WIP 2023-03-25 19:03:59 -04:00
BenCodez da642cb3b2 Stop background task on plugin disable 2023-03-23 16:44:04 -04:00
BenCodez 96c707eca4 Changes to reloading multiproxy support 2023-03-22 19:26:14 -04:00
BenCodez ce5c469637 Update to 6.11.3 2023-03-18 19:17:00 -04:00
BenCodez 4126c4a7a1 Change default maven profile 2023-03-18 16:03:30 -04:00
Ben fb430a930b Create jitpack.yml 2023-03-18 15:57:25 -04:00
BenCodez 2c6f8c79c2 Shutdown multiproxy socket on reload if disabled 2023-03-18 14:52:23 -04:00
BenCodez 1b94f23ff2 Remove softdepend 2023-03-16 17:16:19 -04:00
BenCodez 72c0a88fc1 Load multiproxy support on reload 2023-03-15 16:49:19 -04:00
BenCodez e532987c6a Update to 1.19.4 2023-03-14 16:55:04 -04:00
BenCodez 2168d92b12 Cache almostallsites key 2023-03-07 18:46:26 -05:00
BenCodez d68758f34e Optimize placeholder caching updates 2023-03-05 17:12:32 -05:00
BenCodez e1b7844501 Undo change to bungee handling 2023-03-05 12:39:05 -05:00
BenCodez 01b6ed185b Changes to handling bungee votes 2023-03-04 18:56:35 -05:00
BenCodez 3ee31012ce Update version number to 6.11.2 2023-02-18 19:09:15 -05:00
BenCodez ba312961b8 Optimize player vote event even more 2023-02-12 20:20:50 -05:00
BenCodez a2484969ee Improve vote handling to deal with large databases 2023-02-12 18:51:32 -05:00
BenCodez 470196741c Improve getting user object 2023-02-12 17:17:23 -05:00
BenCodez 2abce5ebe7 Improve background task 2023-02-12 17:14:33 -05:00
BenCodez 20f775c119 Don't always run login/logout rewards unless needed 2023-02-12 13:53:04 -05:00
BenCodez e0821ed2b1 Minor log message change 2023-02-11 21:19:17 -05:00
BenCodez 6fbcc89fc8 Optimize player vote listener slightly 2023-02-11 17:51:13 -05:00
BenCodez 11f86194b0 Changes to how reload is handled 2023-02-11 15:55:21 -05:00
BenCodez 46c112d2ea Don't reload background task on plugin reload 2023-02-10 21:18:07 -05:00
BenCodez 0269578e5e More changes to background task 2023-02-10 21:17:17 -05:00
BenCodez fc14b19d9f Changes to vote processing 2023-02-10 21:11:49 -05:00
BenCodez 9c25f848c6 Add another test command 2023-02-09 19:16:50 -05:00
BenCodez b7f53aabfb Bug fix 2023-02-08 16:57:02 -05:00
BenCodez 926a009085 Remove extra checks 2023-02-08 16:54:34 -05:00
BenCodez f0737861de Add support for whitelist instead of blocked list on proxy 2023-02-07 19:55:00 -05:00
BenCodez 8e14a92813 Add metrics for multi-proxy support 2023-02-05 20:27:32 -05:00
BenCodez 78fc8069b3 More changes to background vote processing handling 2023-02-05 15:40:42 -05:00
BenCodez eed98ed638 Try different locking system for votes 2023-02-05 14:40:39 -05:00
BenCodez f3653c20f6 Silence no votifierevent message when using multiproxy setup 2023-02-05 12:18:59 -05:00
BenCodez 675f4bb6e9 Changes to vote handling 2023-02-04 18:05:13 -05:00
BenCodez 4dbb8b7360 Minor change to background task 2023-02-04 17:38:43 -05:00
BenCodez 5040ee2946 Support velocity booting without nuvotifier installed 2023-02-04 17:24:07 -05:00
BenCodez d7e1408c30 Fix offline broadcast not working correctly on bungee setups 2023-01-29 15:56:49 -05:00
BenCodez 73fda9027a Implement offline broadcast to bungee setups 2023-01-29 15:52:05 -05:00
BenCodez b762c6000f Fix double rewards with mutli-proxy setup 2023-01-29 14:41:08 -05:00
BenCodez 16dcd85807 Fix issues with offline voting on velocity 2023-01-29 14:32:18 -05:00
BenCodez d9b5fcf250 Fix issue on velocity 2023-01-29 14:02:29 -05:00
BenCodez b85f49010b Bug fix 2023-01-29 13:52:17 -05:00
BenCodez 42b64b86bd Add debug messages to multi-proxy setup 2023-01-29 13:28:46 -05:00
BenCodez 266014cbe2 Added /votingpluginbungee multiproxystatus 2023-01-29 13:11:10 -05:00
BenCodez 1e27e28a33 Implement multi-proxy support to velocity 2023-01-29 12:58:23 -05:00
BenCodez 1c530c18ce Change debug to log message 2023-01-27 19:24:41 -05:00
BenCodez c2ebd2251e Bug fix for multi-proxy setup 2023-01-27 19:22:23 -05:00
BenCodez c2fb84dc61 Added extra debug message 2023-01-27 18:56:08 -05:00
BenCodez 39e21bffe7 Minor fixes on multi-proxy handling 2023-01-27 16:58:28 -05:00
BenCodez 226b6eb01e Fix an issue 2023-01-27 16:49:47 -05:00
BenCodez 76a40fd889 Change handling on multi-proxy setup 2023-01-26 19:20:09 -05:00
BenCodez 32f43e7713 Fix issue on bungee login 2023-01-22 16:49:06 -05:00
BenCodez 601e57572f Update version number to 6.11.1 2023-01-21 20:38:01 -05:00
BenCodez 4a8bd40a8b Remove log message 2023-01-21 19:43:32 -05:00
BenCodez 8294e99eeb Change votifier processing 2023-01-21 19:42:16 -05:00
BenCodez 162e7f7faa Change timer handling 2023-01-21 19:11:30 -05:00
BenCodez 7463074b5a Add extra log message 2023-01-21 15:25:12 -05:00
BenCodez bbec19d5c9 Add config option to enable/disable vote queues during time change 2023-01-21 15:23:58 -05:00
BenCodez 72ed4223c4 Improve log messages on vote 2023-01-20 20:50:59 -05:00
BenCodez 603656248b Add another log message 2023-01-20 20:47:04 -05:00
BenCodez 4455a0254f Add extra debug message 2023-01-20 20:04:07 -05:00
BenCodez 3227c47d9b Changes to vote queue 2023-01-19 20:55:53 -05:00
BenCodez bf6885875f Smarter json parsing on voteurl 2023-01-19 19:15:34 -05:00
BenCodez 72934d1286 Change handling of voteparty to better handle last voted player 2023-01-18 19:59:06 -05:00
BenCodez 2a4840814d Fix offline vote processing on bungee 2023-01-17 19:00:17 -05:00
BenCodez 8b8e8acbc8 Modify handling of login on bungee 2023-01-17 17:19:36 -05:00
BenCodez a4ff2d8dcf Fix issues with velocity 2023-01-16 16:43:02 -05:00
BenCodez a6ca0c8121 Update version number to 6.11 2023-01-15 13:48:24 -05:00
BenCodez f3e88859d3 Fix a few issues 2023-01-15 13:37:33 -05:00
BenCodez 7249159ec9 Add more metrics 2023-01-15 12:51:58 -05:00
BenCodez 61c3eccb19 Changes to metrics 2023-01-14 20:41:28 -05:00
BenCodez 4ec800c83e Changes to metrics handling 2023-01-14 19:41:31 -05:00
BenCodez 20e42b0ae7 Fix issue with velocity startup 2023-01-14 15:07:17 -05:00
BenCodez d95becce22 Add geyser prefix to name on vote if needed 2023-01-11 19:06:24 -05:00
BenCodez 04fd38a10d Remove bungee geyser handle 2023-01-11 17:10:16 -05:00
BenCodez a30b2319f5 load metrics async 2023-01-11 17:00:01 -05:00
BenCodez a1b08f6dd0 Small change to voting 2023-01-10 16:50:16 -05:00
BenCodez 614193716f Change order of method 2023-01-09 18:45:15 -05:00
BenCodez b68ac4cdd5 Attempt to get geyser uuid 2023-01-09 18:44:04 -05:00
BenCodez 3767ca2883 Load secretkey.key file if using redis support and not socket method 2023-01-09 17:48:36 -05:00
BenCodez 73b7abf3e6 Add geyser prefix on bungee 2023-01-08 17:29:28 -05:00
BenCodez 285719ae28 Add geyser support to bungee 2023-01-08 17:08:59 -05:00
BenCodez 22fd1ac1e4 Fix listener not registering 2023-01-08 15:07:56 -05:00
BenCodez 6127a2ab23 Add cooldown end rewards per votesite & improve reward edit GUI's 2023-01-07 19:40:03 -05:00
BenCodez 0054b6e06f Add local time change queue handling (non bungee setups) 2023-01-06 20:59:38 -05:00
BenCodez b0f1e0bcb6 Fix vote shop closing 2023-01-06 18:59:25 -05:00
BenCodez ddd0dba728 Implement a better system to test for online servers with global data 2023-01-03 20:22:27 -05:00
BenCodez 9595164f69 Bug fixes 2023-01-03 16:43:10 -05:00
BenCodez 66092ba3fd Fix bungee time queue to actually remember time of vote 2023-01-02 20:37:50 -05:00
BenCodez 5c41c7f4c9 Improve global time handle 2023-01-02 19:36:15 -05:00
BenCodez dfa772af4b Minor change to vote party handling 2023-01-02 14:42:22 -05:00
BenCodez 78f33661aa Improvements to global data handler, handle resets, pause incoming votes 2023-01-01 22:07:52 -05:00
BenCodez 45f2bb2c72 Minor improvements to global data handling 2023-01-01 16:56:23 -05:00
BenCodez f20c7a58ac Add global data handler, WIP 2023-01-01 16:18:02 -05:00
BenCodez 4d1b37c37b Add AlmostAllSites reward 2023-01-01 16:16:43 -05:00
BenCodez d323cd7691 Store top voters before processing rest of time change event 2022-12-27 10:15:19 -05:00
BenCodez 67fc73b530 Delay top voter resetting to improve synchronization between servers 2022-12-27 10:13:38 -05:00
BenCodez 13872fd9d1 Rewrite all sites cooldown event to be a little more efficient 2022-12-19 21:09:00 -05:00
BenCodez a76da52a0a Add per site cooldown end event, enabled with config option 2022-12-19 21:01:58 -05:00
BenCodez 36fabe10a6 Add support for offline mode on bungee 2022-12-17 18:28:55 -05:00
BenCodez eada7af420 Replace placeholderapi placeholders in vote party command 2022-12-13 17:28:22 -05:00
BenCodez 63fc7d64be Update to 6.10.0 2022-12-10 19:42:03 -05:00
BenCodez 0ed5b12f8b Update to 1.19.3 2022-12-08 20:28:00 -05:00
BenCodez 504f9edbb2 Handle invalid materials on voteshop edits 2022-12-02 17:54:37 -05:00
BenCodez 8060ece2eb Update use of timers 2022-11-27 17:03:28 -05:00
BenCodez 254442fa2e Improve new topvoter sorting 2022-11-20 17:48:05 -05:00
BenCodez febead9d5a Bug fix 2022-11-20 17:27:55 -05:00
BenCodez d8cd0c278d Don't cache when sorting top voter 2022-11-20 17:10:54 -05:00
BenCodez fe0d7cd671 Change order of top voter to better handle ties 2022-11-20 14:06:07 -05:00
BenCodez c9d8878bb3 Add extra sorting to top voters 2022-11-20 14:04:30 -05:00
BenCodez 0f450e9b60 Catch NumberFormatException 2022-11-14 18:30:04 -05:00
BenCodez 667d0b544e More changes to timers 2022-10-31 18:44:24 -04:00
BenCodez 6e1e6bd928 Change to ScheduledExecutorService 2022-10-31 17:03:01 -04:00
BenCodez 1cfc447445 Add temp workaround to fix some issues 2022-10-31 16:55:27 -04:00
BenCodez 6d3e68e548 Add placeholder for players that voted in alternate broadcast 2022-10-13 15:53:12 -04:00
BenCodez 855dde196e More improvements for anysitereward with pluginmessaging 2022-10-06 20:39:21 -04:00
BenCodez d5a9e1012a Changes to pluginmessaging to fix anysiterewards 2022-10-05 16:47:36 -04:00
BenCodez f5d67833b2 Update version number to 6.9.5 2022-09-25 15:00:56 -04:00
BenCodez a1eb2f63e5 Fix cache issues on player vote 2022-09-14 20:28:19 -04:00
BenCodez a882b8d86f Undo minor change for cache on vote 2022-09-14 15:42:32 -04:00
BenCodez 0a745ae4c0 Fix issues with cache delays for cumulative/milestones 2022-09-10 15:00:48 -04:00
BenCodez d38a0549d3 Add 1 total to cumulative on local votes to prevent cumulative delay 2022-09-09 20:23:37 -04:00
BenCodez 6e6394f1fb Always update placeholder cache on background update 2022-09-08 19:21:54 -04:00
BenCodez ce58e12740 Fix error with sockets method on broadcasts 2022-09-03 20:46:51 -04:00
BenCodez 2411354a5f Added extra debug for reminders 2022-09-02 20:10:47 -04:00
BenCodez 13efd0c482 Add option for voteparty once per week 2022-08-30 19:36:06 -04:00
BenCodez 8fce74f30d Always store bungee voteparty info incase of restart 2022-08-27 20:14:36 -04:00
BenCodez 3f54c05f86 Update version number to 6.9.4 2022-08-27 19:30:43 -04:00
BenCodez dd1cf02c49 Fix voteparty setextrarequired command 2022-08-22 15:43:35 -04:00
BenCodez b462373dfc Run bstats metrics async 2022-08-20 07:54:20 -04:00
BenCodez c6e5d008d2 Update to 1.19.2 2022-08-07 14:07:31 -04:00
BenCodez 9a91561304 Improve addpoints command 2022-08-04 15:36:19 -04:00
BenCodez 1c6981e538 Change name of plugin in softdepend 2022-07-28 15:48:15 -04:00
BenCodez b6e366ff9d Update to 1.19.1 2022-07-27 18:59:58 -04:00
BenCodez ca0fbe7e3b Update version number to 6.9.3 2022-07-23 16:21:02 -04:00
BenCodez 27d8b3e718 Change gottenmilestones column to be bigger 2022-07-22 20:11:38 -04:00
BenCodez 8430609d0f Fix error on velocity if mysql is not set 2022-07-16 17:16:55 -04:00
BenCodez 8fe5e87999 Improve config comments 2022-07-10 15:06:43 -04:00
BenCodez 6b985e19c2 Add new experimental support for redis, new fully tested 2022-07-03 21:22:17 -04:00
BenCodez 4636cc78b2 Fix an error on velocity 2022-07-03 12:01:12 -04:00
BenCodez 8c66b50749 Fix spelling 2022-06-30 07:57:10 -04:00
BenCodez 7f6e95d47e Clicking icons in /votelast can now open links (if enabled) 2022-06-27 08:11:54 -04:00
BenCodez cd60ade45f Add additional debug for loading votesites 2022-06-26 12:39:24 -04:00
BenCodez f82945b97b Fix typo 2022-06-21 19:37:51 -04:00
BenCodez a3e9651378 Add config option to always process placeholders 2022-06-21 19:14:23 -04:00
BenCodez a764ca0ed7 Undo change 2022-06-21 19:03:51 -04:00
BenCodez d21464560a Minor change in placeholder handling 2022-06-21 19:01:31 -04:00
BenCodez 88c5dc7c86 Update version number to 6.9.2 2022-06-07 16:01:30 -04:00
BenCodez b2b2c710c5 Open gui on votesite creation 2022-06-07 14:09:50 -04:00
BenCodez 4175e2d36a Update 1.19 2022-06-07 13:29:33 -04:00
BenCodez a84adb367d Modify delay to login event 2022-06-02 17:10:46 -04:00
BenCodez 7368158707 Add command /av voteexact 2022-06-02 17:01:36 -04:00
BenCodez 5d3c1cb553 Use exact player name in /av user for forcing a vote 2022-05-29 13:04:58 -04:00
BenCodez cb1206db0b Updates to pluginmessaging and sockets 2022-05-18 20:12:45 -04:00
BenCodez 03396e447f Fix color codes on bungee commands 2022-05-17 20:56:58 -04:00
BenCodez 6dec0826af Update version number to 6.9.1 2022-05-15 15:33:12 -04:00
BenCodez f443f77dfe Add option to set cumulative as recurring 2022-05-13 17:04:04 -04:00
BenCodez 5c4636d8c2 Fixed issues with settings points to quickly, causing lost points 2022-05-12 20:55:22 -04:00
BenCodez 51c6c4066b Add cumulative blacklist 2022-05-12 19:27:02 -04:00
BenCodez 161fc6da95 Improve config comment on bungee 2022-05-08 12:11:10 -04:00
BenCodez aba23f355e Fix some issues with points within rewards 2022-05-07 19:37:59 -04:00
BenCodez ac78b4d350 Fix error on bungee 2022-04-27 17:30:41 -04:00
BenCodez 0c01f8d3c1 Update version number to 6.9 2022-04-24 15:15:57 -04:00
BenCodez 77dc7d51f5 Fix alternate broadcast broadcasting 0 votes on each login 2022-04-24 14:48:27 -04:00
BenCodez ee5c4db0c9 Fix playerjoinevent not working 2022-04-24 14:46:06 -04:00
BenCodez f9b47c5c63 Fix vote point adding in rewards 2022-04-18 16:59:56 -04:00
BenCodez d7dc82b1a7 Add extra checks 2022-04-18 16:57:57 -04:00
BenCodez c5041edd8a Add exr 2022-04-18 16:57:20 -04:00
BenCodez d52b7f85b3 use new method to get reward handler 2022-04-15 20:15:58 -04:00
BenCodez 3e4564578a CHange points reward handling 2022-04-15 14:35:07 -04:00
BenCodez 65312cd2a1 Add config option to only broadcast once for offline votes 2022-04-14 20:36:19 -04:00
BenCodez b2db9675ca Add ability to check if player doesn't have permission for vote shop 2022-04-13 16:47:09 -04:00
BenCodez 0a66c2dd7e Synchronize points adding 2022-04-06 17:36:20 -04:00
BenCodez 7c02cb91f4 Update version number to 6.8.4 2022-03-26 21:16:18 -04:00
BenCodez 3a390659cd Reenable config option 2022-03-26 20:16:11 -04:00
BenCodez 99bd32c8f5 Improve placeholder cache 2022-03-24 19:59:00 -04:00
BenCodez de894a98b2 Disable auto cache placeholders when no config option present 2022-03-24 17:35:00 -04:00
BenCodez 8c668289ce Add config options for mysql 2022-03-20 14:14:04 -04:00
BenCodez 95e850cb84 Add blacklist for rewards broadcasts 2022-03-20 12:48:03 -04:00
BenCodez d2134abc45 Fix broadcast blacklist not working on bungee setups 2022-03-19 17:10:47 -04:00
BenCodez 3316662889 Add default top voter material item 2022-03-05 21:57:15 -05:00
BenCodez 5b3ced6ca9 Attempt to fix /vote help for 1.12 2022-03-05 18:54:37 -05:00
BenCodez 50a5169543 Add extra check for background task for shutdowns 2022-03-03 16:52:23 -05:00
BenCodez c8d5e2f4b5 Have placeholders return error message rather than dots 2022-03-02 17:33:05 -05:00
BenCodez 3dcd78e4f5 change vote processing to java timers (hopes to reduce thread usage) 2022-02-22 16:51:18 -05:00
BenCodez de570574c9 Fix potential NPE on velocity shutdown 2022-02-20 16:52:32 -05:00
BenCodez 116eda2866 Update version number to 6.8.3 2022-02-20 13:44:33 -05:00
BuildTools 30f1576510 Fix creating milestones in GUI not working correctly 2022-02-19 17:00:05 -05:00
BuildTools 64e897615a use java timer for login/logout event 2022-02-18 19:16:18 -05:00
BuildTools 2dfd8dcfa5 Update version number to 6.8.2 2022-02-13 15:59:08 -05:00
BuildTools 00791766f1 Change default value of config option 2022-02-13 14:28:26 -05:00
ben 4d2c783d85 Improve getting uuid on proxy setups, more efficient 2022-02-11 17:14:05 -05:00
ben 19f1664662 Ignore casing when checking for disabled votesites 2022-02-06 12:34:01 -05:00
ben ca2e6fb530 Add extra null check 2022-02-02 16:57:28 -05:00
Ben eca7c6641a Merge pull request #1220 from pseudoforceyt/patch-1
Fix bungee setup wiki link
2022-01-24 16:46:52 -05:00
Ilamparithi M 47fe6b57e2 Fix bungee setup wiki link 2022-01-24 19:34:57 +05:30
ben 911819c69b Fix weekly top voters rewards feeding off monthly top voters 2022-01-23 14:03:25 -05:00
ben cda72b5c5b Let AdvancedCore handle vanished players 2022-01-23 13:18:16 -05:00
ben 75a3da98fa Change dependency 2022-01-22 15:24:13 -05:00
ben ced74fdee3 Changes to vanish event 2022-01-22 14:22:58 -05:00
ben b8460ff755 Add debug message for vanish login 2022-01-21 22:08:29 -05:00
ben 50bb1facc4 Modify event handling for playershowevent 2022-01-21 21:20:54 -05:00
ben 5ed21949e1 Add soft depends 2022-01-19 21:28:09 -05:00
ben 253e4937db Fix playershowevent not working completely 2022-01-19 19:51:32 -05:00
ben 192685ceec Add playershowevent for vanished players 2022-01-19 17:10:38 -05:00
BenCodez 16de063e51 Update version number to 6.8.1 2022-01-15 20:43:35 -05:00
BenCodez 1d3ce9ed64 Add another check 2022-01-14 21:50:21 -05:00
BenCodez d357c927c8 Add extra checks to ensure plugin is enabled before processing a vote 2022-01-14 21:47:33 -05:00
BenCodez 1143595238 modify placeholders 2022-01-13 20:57:33 -05:00
BenCodez 0917c36889 Add null check for player in placeholders 2022-01-12 18:57:12 -05:00
BenCodez c113214ae0 Add extra check on placeholders 2022-01-12 16:44:47 -05:00
BenCodez b2c444d125 Add PlayerPostVoteEvent 2022-01-11 21:04:50 -05:00
BenCodez 78fdce0eab fix npe 2022-01-10 18:51:02 -05:00
BenCodez feff09eccb Fix potential NPE 2022-01-09 17:35:57 -05:00
BenCodez d0646472bf Fix typos in votesites.yml 2022-01-09 11:22:29 -05:00
BenCodez 8471f50402 Fix certain placeholders not working 2022-01-06 19:28:13 -05:00
BenCodez 621450dae4 Add option to enable/disable auto placeholder cache 2022-01-03 21:15:16 -05:00
BenCodez 84e415e4bc Update version number to 6.8 2022-01-03 10:41:31 -05:00
BenCodez 54bbc8c740 Adding auto placeholder caching 2022-01-03 10:02:45 -05:00
BenCodez 7b1ab7e833 Code cleanup 2021-12-30 20:27:21 -05:00
BenCodez acb8f8a43f Code cleanup 2021-12-30 20:20:44 -05:00
BenCodez 279759b52f Code cleanup 2021-12-30 20:13:27 -05:00
BenCodez 02ca0b1fc8 Give players vote party reward, even if player has no reward data 2021-12-29 18:36:27 -05:00
BenCodez d57e3d1006 Add option to limit player data loading 2021-12-28 17:35:39 -05:00
BenCodez d54769eb82 Add command alias 2021-12-23 21:57:47 -05:00
BenCodez 35f6a3df15 Start progress on bungee time handling, keeps bungee in sync 2021-12-23 19:35:30 -05:00
BenCodez 46b66466ba Add ability to toggle vote reminders 2021-12-23 19:05:26 -05:00
BenCodez 53fbe4e5e2 Changes to placeholders 2021-12-21 18:55:12 -05:00
BenCodez 53ef7a7086 Add another event 2021-12-20 16:46:36 -05:00
BenCodez b0e08721fa Add scope to redis dependency 2021-12-19 21:00:20 -05:00
BenCodez 29dad6ca25 Add null check for redis 2021-12-19 17:48:03 -05:00
BenCodez 7c3e5eb09b Add bungee vote party placeholders 2021-12-19 14:40:50 -05:00
BenCodez a7776ec97c Hide socket settings by default to avoid confusion 2021-12-19 13:18:27 -05:00
BenCodez d598082c0a Add cache system for placeholders 2021-12-18 21:19:38 -05:00
BenCodez 4539b5b22a Add extra permission checks 2021-12-14 16:53:49 -05:00
BenCodez 02fe645d1e More changes to vote party commands 2021-12-12 12:52:37 -05:00
BenCodez ee8af6a314 Modify voteparty commands, add new ones to set/add totals 2021-12-12 12:49:50 -05:00
BenCodez a4b78c7d16 More fixes for redis 2021-12-11 08:20:20 -05:00
BenCodez d22fe462e5 Test change for redis 2021-12-10 17:02:53 -05:00
BenCodez c19182a2b4 Reuse config option 2021-12-07 17:32:03 -05:00
BenCodez 6905c3988b Remove option, auto enable redis support 2021-12-07 17:28:08 -05:00
BenCodez 23be120adc Small changes 2021-12-07 17:18:19 -05:00
BenCodez dae863f88f Bug fix 2021-12-07 17:07:54 -05:00
BenCodez d12f73d2fa Add option for redis bungee 2021-12-07 17:01:51 -05:00
BenCodez 316ee90713 Slight improvement to login events on bungee 2021-12-07 16:57:13 -05:00
BenCodez 1495fad96f Add softdepend 2021-12-07 16:47:23 -05:00
BenCodez 8e0de1709b Add permission requirements to base admin command 2021-12-06 18:52:57 -05:00
BenCodez ad22802e10 Remove unused command in plugin.yml 2021-12-06 16:53:21 -05:00
BenCodez 6de0345f06 Add option for backbutton on best GUI 2021-12-05 14:20:38 -05:00
BenCodez 7338a7d8ba added best and streak GUI's to vote gui ability to open 2021-12-05 13:32:44 -05:00
BenCodez 3ca12f2c91 Add expiremental redis support, untested 2021-12-05 12:51:13 -05:00
BenCodez 262e7c48c7 Fix socket method on velocity 2021-12-04 18:46:38 -05:00
BenCodez 0b62d99f9d Add debug for velocity socket method 2021-12-04 14:59:31 -05:00
BenCodez ea30de47d1 Update version number to 6.7.1 2021-11-28 19:11:17 -05:00
BenCodez a76daf3aba Modify debug on bungee 2021-11-28 16:46:58 -05:00
BenCodez e1ff13f4bf Add more debug for bungee for testing 2021-11-28 16:35:53 -05:00
BenCodez 12f941cf83 Add option for per server milestones 2021-11-27 20:21:42 -05:00
BenCodez 243377a76a More changes for 1.18 support 2021-11-27 19:38:15 -05:00
BenCodez d7eab03860 Fix bungee debug always active when it shouldn't 2021-11-27 17:21:10 -05:00
BenCodez ddd1f473f1 Properly reset gotten milestones on /av resyncmilestonesalreadygiven 2021-11-23 16:51:57 -05:00
BenCodez 3e52bb0936 Update library to support 1.18 2021-11-21 20:56:55 -05:00
BenCodez eb60220b1e Undo vote thread changes 2021-11-17 16:41:49 -05:00
BenCodez 00902bd597 Add a vote thread to prevent hitting resource limit 2021-11-15 17:22:48 -05:00
BenCodez d3606088cd Add option to only give 1 cumulative at a time 2021-11-07 13:55:18 -05:00
BenCodez ef2512e4e2 Change log level to info for using dev build 2021-11-01 16:41:55 -04:00
BenCodez 7f95a1c7c3 Fix issue with votereminding on shutdown 2021-10-21 16:42:54 -04:00
BenCodez 68a2fe27ff Update version number to 6.7 2021-10-10 14:08:38 -04:00
BenCodez b05317c460 Fix a few things with bungee voteparty 2021-10-10 13:50:47 -04:00
BenCodez 62fee6f347 Fix voteshop confirm not going back to main voteshop gui when it should 2021-10-05 20:25:44 -04:00
BenCodez ef7d4254e1 Fix more issues with velocity 2021-10-03 14:07:36 -04:00
BenCodez b6720ccc1f Fix issue on velocity 2021-10-03 13:52:43 -04:00
BenCodez 69d3d33008 Fix issue on velocity 2021-10-03 12:33:18 -04:00
BenCodez 7a193c87a9 Add vote party on bungee, online only, partly tested 2021-09-27 20:16:25 -04:00
BenCodez f2cf2fb734 Fix top voter clicking in GUI 2021-09-25 15:43:53 -04:00
BenCodez 836079b5ea Prevent NPE 2021-09-19 12:02:55 -04:00
BenCodez a7f6456480 Add option for closing inventory on vote 2021-09-17 17:15:51 -04:00
BenCodez 82f25c3899 Add debug message for disabled milstone 2021-09-13 17:23:22 -04:00
BenCodez cb2cdbd4fc Add points placeholder to vote shop 2021-09-08 16:59:15 -04:00
BenCodez 40d2b651a8 Update version number to 6.3.3 2021-09-05 12:26:42 -04:00
BenCodez a999d9e9bb Sync votes better with cache 2021-09-01 18:59:09 -04:00
BenCodez b144f2db9c Small change to caching on voting 2021-09-01 18:50:01 -04:00
BenCodez 24060a10ed Small improvement 2021-09-01 14:56:17 -04:00
BenCodez 4c8919804f Prevent duplicate broadcasts if bungee broadcasts 2021-08-30 15:21:59 -04:00
BenCodez 66618260bb Update version number to 6.6.2 2021-08-29 13:28:29 -04:00
BenCodez f441ede6b0 Bug fix 2021-08-29 12:47:04 -04:00
BenCodez 593ae76354 Modify metrics and message 2021-08-28 18:14:01 -04:00
BenCodez aa49dc5bc1 Improve proxy offline voting handling 2021-08-25 15:22:04 -04:00
BenCodez 8941d909ca Add synchronization to offline vote checks on proxy 2021-08-24 14:48:53 -04:00
BenCodez 2946792dec Change handling of some vote top commands 2021-08-23 19:06:41 -04:00
BenCodez 0567f0ac66 Add disablebroadcast to a few other areas 2021-08-22 17:20:26 -04:00
BenCodez fe78992477 Update config values 2021-08-22 14:44:09 -04:00
BenCodez 195e1c82bd Enable broadcast option on bungee to work for pluginmessaging 2021-08-22 14:42:23 -04:00
BenCodez 9479fe06c0 Modify broadcast handling 2021-08-22 14:32:45 -04:00
BenCodez 0807caed98 Fix potential issues 2021-08-20 15:02:35 -04:00
BenCodez 9fdcf5aa78 Fix update message contain invalid command & clear cache on adding point 2021-08-17 18:43:28 -04:00
BenCodez 8d26e66dc0 Remove jars 2021-08-16 19:02:10 -04:00
BenCodez 14e61ba6bf Update version to 6.6.1 2021-08-16 18:26:51 -04:00
BenCodez 6d361cc83f Shutdown mysql on bungee/velocity on shutdown 2021-08-16 16:44:32 -04:00
BenCodez 1e32fd65e0 Remove files 2021-08-16 14:59:56 -04:00
Ben 5f0d8fff2f Update .gitignore 2021-08-16 14:59:26 -04:00
BenCodez 0d828a99bc Add more info about build number 2021-08-15 20:30:44 -04:00
BenCodez 0e8bd23784 Undo repo change 2021-08-15 19:01:02 -04:00
BenCodez a8af2a49ad Change build setup 2021-08-15 18:42:17 -04:00
BenCodez 54b08019ec Fix getting build number 2021-08-15 18:35:37 -04:00
BenCodez 27f01a6c3a Remove build number on version command 2021-08-15 17:50:00 -04:00
BenCodez 337aab384f Add build number info on startup 2021-08-15 17:45:41 -04:00
BenCodez a94e1c1dd6 Add build number information for jenkins 2021-08-15 17:19:28 -04:00
BenCodez 1445d97ce0 Bug fix 2021-08-15 17:02:44 -04:00
BenCodez 9e8abe0768 Fix issue on velocity with votes 2021-08-15 16:52:21 -04:00
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
115 changed files with 10074 additions and 4406 deletions

No files matched your search

+7 -12
View File
@@ -2,30 +2,25 @@
Plugin on SpigotMC
https://www.spigotmc.org/resources/votingplugin.15358/
![img](http://badge.henrya.org/spigot/downloads?id=15358&color=green)
![img2](http://badge.henrya.org/spigot/version?id=15358&color=red)
## License
### Creative Commons Arttribution 3.0 Unported
https://github.com/Ben12345rocks/VotingPlugin/blob/master/VotingPlugin/Resources/LICENSE.txt
https://github.com/BenCodez/VotingPlugin/blob/master/VotingPlugin/Resources/LICENSE.txt
### Maven:
<repository>
<id>jitpack.io</id>
<url>https://jitpack.io</url>
<id>BenCodez Repo</id>
<url>https://nexus.bencodez.com/repository/maven-public/</url>
</repository>
<dependency>
<groupId>com.github.BenCodez</groupId>
<artifactId>VotingPlugin</artifactId>
<groupId>com.bencodez</groupId>
<artifactId>votingplugin</artifactId>
<version>LATEST</version>
<scope>provided</scope>
</dependency>
</dependency>
Versions:
LATEST - latest stable release
BRANCH-SNAPHSOT - unstable builds
-25
View File
@@ -1,25 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" output="target/classes" path="src">
<attributes>
<attribute name="optional" value="true"/>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
<attributes>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry exported="true" kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
<attributes>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry excluding="**" kind="src" output="target/classes" path="Resources">
<attributes>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="output" path="target/classes"/>
</classpath>
+5 -1
View File
@@ -1,3 +1,7 @@
/bin/
/target/
/doc/
/doc/
/.idea/
/*.iml
/.settings/
/.classpath
@@ -1,7 +0,0 @@
add_todo=false
eclipse.preferences.version=1
include_subpackages=true
mode=mode_replace
project_specific_settings=true
replacements=<?xml version\="1.0" standalone\="yes"?>\n\n<replacements>\n<replacement key\="get" scope\="1" mode\="0">Gets the</replacement>\n<replacement key\="set" scope\="1" mode\="0">Sets the</replacement>\n<replacement key\="add" scope\="1" mode\="0">Adds the</replacement>\n<replacement key\="edit" scope\="1" mode\="0">Edits the</replacement>\n<replacement key\="remove" scope\="1" mode\="0">Removes the</replacement>\n<replacement key\="init" scope\="1" mode\="0">Inits the</replacement>\n<replacement key\="parse" scope\="1" mode\="0">Parses the</replacement>\n<replacement key\="create" scope\="1" mode\="0">Creates the</replacement>\n<replacement key\="build" scope\="1" mode\="0">Builds the</replacement>\n<replacement key\="is" scope\="1" mode\="0">Checks if is</replacement>\n<replacement key\="print" scope\="1" mode\="0">Prints the</replacement>\n<replacement key\="has" scope\="1" mode\="0">Checks for</replacement>\n</replacements>\n\n
use_internal_formatter=true
@@ -1,4 +0,0 @@
eclipse.preferences.version=1
encoding/<project>=Cp1252
encoding/Resources=Cp1252
encoding/src=Cp1252
@@ -1,30 +0,0 @@
eclipse.preferences.version=1
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
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
org.eclipse.jdt.core.compiler.compliance=1.8
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.assertIdentifier=error
org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
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.missingJavadocComments=warning
org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=disabled
org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=public
org.eclipse.jdt.core.compiler.problem.missingJavadocTagDescription=all_standard_tags
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.reportPreviewFeatures=ignore
org.eclipse.jdt.core.compiler.release=disabled
org.eclipse.jdt.core.compiler.source=1.8
@@ -1,2 +0,0 @@
eclipse.preferences.version=1
org.eclipse.ltk.core.refactoring.enable.project.refactoring.history=false
@@ -1,4 +0,0 @@
activeProfiles=dev
eclipse.preferences.version=1
resolveWorkspaceProjects=true
version=1
@@ -1,3 +0,0 @@
eclipse.preferences.version=1
project.repository.kind=github
project.repository.url=http\://github.com/Ben12345rocks/VotingPlugin
@@ -1,8 +0,0 @@
DELEGATES_PREFERENCE=delegateValidatorList
USER_BUILD_PREFERENCE=enabledBuildValidatorList
USER_MANUAL_PREFERENCE=enabledManualValidatorList
USER_PREFERENCE=overrideGlobalPreferencesfalse
eclipse.preferences.version=1
override=false
suspend=false
vf.version=3
@@ -1,2 +0,0 @@
eclipse.preferences.version=1
org.jboss.ide.eclipse.as.core.singledeployable.deployableList=\n
Binary file not shown.
Binary file not shown.
+68 -18
View File
@@ -1,18 +1,18 @@
# --------------------------
##########################################
# Bungee Setup
# Only if using votingplugin bungee to send votes
# REQUIRES RESTART FOR CHANGES TO TAKE EFFECT
# --------------------------
##########################################
# Plugin using bungee, requires plugin on bungee server
UseBungeecord: false
# What type of bungee setup
# Requires restart and set on all servers
# https://github.com/Ben12345rocks/VotingPlugin/wiki/Bungeecoord-Setups
# https://github.com/BenCodez/VotingPlugin/wiki/Bungeecord-Setups
# Available:
# SOCKETS
# PLUGINMESSAGING
# PLUGINMESSAGING (Recommended)
# MYSQL
BungeeMethod: PLUGINMESSAGING
@@ -29,12 +29,25 @@ BungeeBroadcast: false
# Whether to broadcast on cached votes
BungeeBroadcastAlways: false
# If true, the server won't broadcast votes
# To be used in conjuction with Broadcast setting on bungee
DisableBroadcast: 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, milestones work per server
# Please note totals still sync, but milestones can be claimed on each server
# Needs to be set across all needed servers
PerServerMilestones: 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
@@ -43,18 +56,55 @@ TriggerVotifierEvent: false
# Also can be applied to rewards
Server: PleaseSet
# -----------------------------
# For socket setup below only
# -----------------------------
# Rewards from bungee vote party
# Gives to only players only
# Use regular voteparty rewards otherwise
# Can edit via /av gui
BungeeVotePartyRewards: {}
# Bungee communication, add bungee host/port here
# For socket method
BungeeServer:
Host: '127.0.0.1'
Port: 1297
# Bungee communication, add this to bungee server
# For socket method
SpigotServer:
Host: '127.0.0.1'
Port: 1298
# List of commands to run on bungee party
# This runs a one time command only
BungeeVotePartyGlobalCommands: []
####################################################################################
# Global mysql data handle for between server commmunications
# This is NOT required for bungee voting to work
# This is still a WIP, use with caution
# This will create a different table then from users storing server info to process
#
# If you use this you need to enable this on BungeeSettings.yml on each server with votingplugin
# Make sure server name is set correctly in BungeeSettings.yml or this will not work correctly
#
# Please use PLUGINMESSAGING for this, SOCKETS should work as well, but not fully tested
#
# This will make votes cache until time change has finished processing
# In the event a server is offline or time change fails, the time change process
# will continue after a set amount of time (in essense skipping a specific server)
# This will also respect blocked servers in bungeeconfig.yml
GlobalData:
Enabled: false
# Use existing mysql connection from config.yml
UseMainMySQL: true
# Mysql settings only used if above is false
Host: ''
# Default port is 3306
Port: 3306
Database: ''
Username: ''
Password: ''
# Max number of connections
MaxConnections: 1
# Must be the same on all servers
Prefix: ''
#UseSSL: true
#PublicKeyRetrieval: false
#Attempt to use mariadb driver
#UseMariaDB: false
##########################################
# For socket setup
# Recommend to try PLUGINMESSAGING setup first
# Options hidden by default to avoid confusion
##########################################
# Options available here:
# https://github.com/BenCodez/VotingPlugin/wiki/Bungee-Setup-SOCKETS
+292 -218
View File
@@ -1,10 +1,14 @@
# 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++
#
###########################################
# User storage
###########################################
# Valid Options:
# - SQLITE
# - FLAT
@@ -22,87 +26,52 @@ MySQL:
Password: ''
# Max number of connections
MaxConnections: 1
# Maxium size of caching mysql
# -1 for no limit
# Affecting this value may affect performance
MaxSize: -1
# Table name prefix, for use with mutliple servers
# Don't use with PLUGINMESSAGING bungee setup
Prefix: ''
#UseSSL: true
#PublicKeyRetrieval: false
# ---------------------------------------------------------
# Mysql cache options
# Clearing cache forces the plugin to pull from database
# Not needed unless you are using multiple servers
# If using a bungee setup most of these options are overriden automatically
# ---------------------------------------------------------
#MaxLifeTime: -1
#Additional info on connection string
#Line: ''
#Attempt to use mariadb driver
#UseMariaDB: false
# Clear cache on update, setting to true reduces update speed
# Also may require AlwaysUpdate set to true
ClearCacheOnUpdate: false
# Clear cache on player join always
ClearCacheOnJoin: false
# Clears cache for the player who voted only
# Only effects if using mysql
# Would recommend for some bungee setups
ClearCacheOnVote: false
# Clear cache when player leaves
ClearCacheOnLeave: false
ClearCacheOnVoteShopPurchase: true
# --------------------
# AllowUnJoined options
# May need to set to true for bungee setup
# --------------------
# Let players who never joined before vote
# Recommend: False (Will prevent creating random user data)
AllowUnjoined: false
# Use server lookup for when allowunjoined is set to false
# Recommend leaving enabled unless you face issues
AllowUnJoinedCheckServer: true
# ------------------------------------------------
###########################################
# VoteReminding
# ------------------------------------------------
###########################################
# 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% sites to vote on still!'
Title:
Enabled: false
Title: '&cRemember to vote!'
@@ -114,9 +83,9 @@ VoteReminding:
Message: '&cRemember to vote'
Delay: 30
# ------------------------------------------------
# Format
# ------------------------------------------------
###########################################
# Format options
###########################################
# Common PlacesHolders:
# Special PlaceHolders will be commented where available
@@ -132,7 +101,11 @@ Format:
# Broadcast vote message
# Set to an empty message to disable
# Use %NewLine% for a new line
BroadcastMsg: '&6[&4Broadcast&6] &2Thanks &c%player% &2for voting on %SiteName%'
# If true uses broadcast setting below for offline votes
OnlyOneOfflineBroadcast: false
OfflineBroadcast: '&6[&4Broadcast&6] &2Thanks &c%player% &2for voting on %numberofvotes% times!'
# Broadcast only when player is online
BroadcastWhenOnline: false
@@ -140,6 +113,8 @@ Format:
# Broadcast every x number of minutes with number of players that voted
AlternateBroadcast:
Enabled: false
# Use %players% for all players names
# Use %numberofplayers% for number of players that voted
Broadcast: '&6[&4Broadcast&6] &2%numberofplayers% voted in the last half hour! /vote'
# Delay in minutes
Delay: 30
@@ -231,6 +206,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
@@ -271,6 +249,10 @@ Format:
ToggleBroadcasts:
Enabled: '&cYou will now see vote broadcasts'
Disabled: '&cYou will no longer see vote broadcasts'
ToggleReminders:
Enabled: '&cVote reminders enabled'
Disabled: '&cVote reminders disabled'
# Msg on top voter award, will only send message if that place has a reward set
# %place% = place - 1,2,3,etc
@@ -339,11 +321,19 @@ Format:
Weekly: 'Weekly'
Monthly: 'Monthly'
AllTime: 'AllTime'
# Playernames to not be broadcasted when voting
# case sensitive
VotingBroadcastBlacklist: []
# ------------------------------------------------
# Playernames to not be broadcasted when broadcast comes from reward file
# case sensitive
BroadcastBlacklist: []
###########################################
# Top Voter
# Top voter rewards available in specialrewards.yml
# ------------------------------------------------
###########################################
# Top voter blacklist
# Hide these names from top voter lists
@@ -371,7 +361,7 @@ 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.
@@ -379,104 +369,13 @@ MaxiumNumberOfTopVotersToLoad: -1
StoreTopVoters:
Weekly: false
Daily: false
# ------------------------------------------------
# Advanced
# Most of these values can be left untouched for most setups
# ------------------------------------------------
# If true vanished players are treated as if they are offline
TreatVanishAsOffline: false
# If true, cooldown check is disabled
DisableCoolDownCheck: false
# If true, disable PlayerInteractEvent (for clicking signs and skulls)
DisableInteractEvent: false
# Delays login event, delays vote reminding and more
# In ticks
DelayLoginEvent: 0
# If false, votestreaks will be disabled
UseVoteStreaks: true
# If false, storing best totals will be disabled
UseHighestTotals: true
# If true, /vote will open /vote gui by default
UseVoteGUIMainCommand: false
# Number of points to give on vote
# Set to 0 to give no points
PointsOnVote: 1
# Set this to false to disable the plugin adding totals
# Not really recommended
AddTotals: true
# If true, items given for rewards are dropped on the ground
# If false, items will be given when there is space
DropOnFullInv: true
# If true, allsites will have an extra check to prevent duplicate allsites from being given
ExtraAllSitesCheck: false
# Click sound when using gui
# Set to none for no sound
ClickSound:
Sound: 'UI_BUTTON_CLICK'
Volume: 1.0
Pitch: 1.0
# Playernames to not be broadcasted when voting
# case sensitive
VotingBroadcastBlacklist: []
# When enabled, javascript will be parsed on placeholders (from placeholderapi)
# allows more fancy placeholders with math for example
UseJavascriptPlaceholders: false
# Limit monthly votes to number of days of a month multipled by the number of sites
LimitMonthlyVotes: false
# This is an extra safe guard to prevent milestones
# from being executed more than once
# Shoudn't be needed, but enable if you have trouble with milestones
PreventRepeatMilestones: false
# When enabled the command /vote setprimaryaccount (playername)
# will be shown (after restart)
# Primary account will be used instead of the players account to get
# placeholder and other data such as vote reminding
# Mainly to be used for alts and such
UsePrimaryAccountForPlaceholders: false
# If true, permissions will be handled differently
MultiplePermissionsCheck: false
AddCustomCommands: false
# Injects custom command to /vote
# Requires AddCustomCommand: true to be set
CustomCommands:
# identifier, not specific name
command1:
Args:
- token
# Message to send on command
Message: 'token message'
# Permission for this command
Permission: 'votingplugin.commands.vote.token'
# help message
HelpMessage: 'See tokens'
# Forces player to run this command
Commands:
- tokencommand
######################
###########################################
# Debug
######################
###########################################
# Debug levels:
# NONE
@@ -498,16 +397,70 @@ DebugInGame: false
# Not recommended though
LogVotesToFile: false
# Only update in the background when needed when set to false
AlwaysUpdate: false
###########################################
# Placeholderapi placeholders settings
###########################################
# Update in the background only if players are online
UpdateWithPlayersOnlineOnly: false
# When enabled the command /vote setprimaryaccount (playername)
# will be shown (after restart)
# Primary account will be used instead of the players account to get
# placeholder and other data such as vote reminding
# Mainly to be used for alts and such
UsePrimaryAccountForPlaceholders: false
# Delay between background updates like signs and more
# Default: 3 Minutes
# Longer times result in longer wait in stuff updating after a vote, like topvoter
DelayBetweenUpdates: 3
# Valid Options:
# AUTO - Auto cache after they have been used (Recommended)
# SPECIFIC - Only cache certain placeholders
# NONE - Don't cache any placeholders
PlaceholderCacheLevel: AUTO
# Placeholder controls
# Add _process to end of placeholder to force a return value rather than . or .. if no cached value is ready
# Add _nocache to end of placeholder to skip cache and retrive a live value, uses a direct mysql connection, do not use on main thread
#
# Set which placeholders to cache at all times
# Use for placeholders to are pulled constantly or on the main thread
# Mainly aimed for scoreboards that pull placeholders often
# Placeholders may auto cache in certain conditions (if enabled above)
# Will use additional memory, but not a lot
# Still in early stages, please report bugs
# Please remove VotingPlugin_ from the placeholder listed here
CachedPlaceholders: []
#- Total_AllTime
# When enabled, javascript will be parsed on placeholders (from placeholderapi)
# allows more fancy placeholders with math for example
UseJavascriptPlaceholders: false
###########################################
# Login options
###########################################
# If true vanished players are treated as if they are offline
TreatVanishAsOffline: false
# Delays login event, delays vote reminding and more
# In miliseconds, 1000 = 1 second
DelayLoginEvent: 0
# Wait until user is logged in with AuthMe
# Requires AuthMe
WaitUntilLoggedIn: true
###########################################
# Disable/Enable features
###########################################
# If true, cooldown check is disabled
DisableCoolDownCheck: false
# If true, disable PlayerInteractEvent (for clicking signs and skulls)
DisableInteractEvent: false
# Disable this on a hub server for example
# Still processes rewards for offline rewards (just won't give any)
ProcessRewards: true
# Set to true to disable no service site message on voting
# You should never have to touch this if everything is setup properly
@@ -518,6 +471,97 @@ DisableNoServiceSiteMessage: false
# If true fake votes will give points and totals
CountFakeVotes: true
# Whether or not to disable update checks
DisableUpdateChecking: false
# Enable per site cooldown events, requires more resources to use
# Requires restart
PerSiteCoolDownEvents: false
# Queue votes during a time change (doesn't apply to bungee voting)
# Votes will be given when time change is completed
QueueVotesDuringTimeChange: false
# If true, plugin will automaticly generate votesites
# Disable this if you experience issues with sites being created randomly
# Most cases this will work all the time
AutoCreateVoteSites: true
# Set this to false to disable the plugin adding totals
# Not really recommended
AddTotals: true
# If false, votestreaks will be disabled
UseVoteStreaks: true
# If false, storing best totals will be disabled
UseHighestTotals: true
# Enable Geyser prefix support
# Geyser support is hit or miss currently
# May work best if players vote with prefix
GeyserPrefixSupport: false
GeyserPrefix: '*'
# Whether or not to create daily backups. (Only the most recent ones get kept)
CreateBackups: true
# Automaticly download the latest version
# Will require a restart to actually update
# Note: It takes 30-40 minutes before being able to download the latest build
# You can also use /av download
AutoDownload: false
# If false plugin will use offline player UUIDs
OnlineMode: true
# Disable checking on world change
# May improve performance
#DisableCheckOnWorldChange: false
###########################################
# Skull settings
###########################################
# 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 (very little) if disabled, but slow GUI speeds when using skulls
LoadSkulls: true
###########################################
# Extra checks on vote
###########################################
# If true, allsites will have an extra check to prevent duplicate allsites from being given
ExtraAllSitesCheck: false
# This is an extra safe guard to prevent milestones
# from being executed more than once
# Shoudn't be needed, but enable if you have trouble with milestones
PreventRepeatMilestones: false
# Number of points to give on vote
# Set to 0 to give no points
PointsOnVote: 1
# May need to enable this for bungee setups
# Let players who never joined before vote
# Recommend: False (Will prevent creating random user data)
AllowUnjoined: false
# Use server lookup for when allowunjoined is set to false
# Recommend leaving enabled unless you face issues
AllowUnJoinedCheckServer: true
##############################################
# Command/Permission settings
##############################################
# Give VotingPlugin.Player by default
# Requires restart to take affect
GiveDefaultPermission: true
@@ -526,56 +570,17 @@ GiveDefaultPermission: true
# Permissions listed here will no be accessible with the default permission
DisabledDefaultPermissions: []
# Remove old player files
# Happens on startup or /av purge
PurgeOldData: false
# Minimum number of days offline in order to purge
PurgeMin: 90
# Whether or not to create daily backups. (Only the most recent ones get kept)
CreateBackups: true
# If true, plugin will automaticly generate votesites
# Disable this if you experience issues with sites being created randomly
# Most cases this will work all the time
AutoCreateVoteSites: true
# Automaticly download the latest version
# Will require a restart to actually update
# Note: It takes 30-40 minutes before being able to download the latest build
# You can also use /av download
AutoDownload: false
# Whether or not to disable update checks
DisableUpdateChecking: false
# Allow transfer of vote points between players
AllowVotePointTransfers: false
# Disable this on a hub server for example
# Still processes rewards for offline rewards (just won't give any)
ProcessRewards: true
# If true, /vote will open /vote gui by default
UseVoteGUIMainCommand: false
# Disable checking permissions on tab complete
# Could increase performance slightly, but probably not
DisableAdvancedTab: false
# Load command aliases, such as /avgui
# Requires restart to take effect
LoadCommandAliases: true
# Wait until user is logged in with AuthMe
# Requires AuthMe
WaitUntilLoggedIn: true
# Preload skulls to improve performance
# If false, skulls will be cached as they are used
PreloadSkulls: false
# Setting to false disables saving skulls in a cache to improve speeds
# Will reduce ram usage if disabled
LoadSkulls: true
# Use vault for permission checks
# May not work on some plugins
UseVaultPermissions: false
@@ -586,26 +591,101 @@ UseVaultPermissions: false
# - PERMISSION
DisabledCommands: []
# Enable Geyser prefix support
GeyserPrefixSupport: false
GeyserPrefix: '*'
# If true, permissions will be handled differently
MultiplePermissionsCheck: false
# Allow transfer of vote points between players
# Requires restart for command to load
# Command: /vote givepoints (player) (points)
AllowVotePointTransfers: false
AddCustomCommands: false
# Injects custom command to /vote
# Requires AddCustomCommand: true to be set
CustomCommands:
# identifier, not specific name
command1:
Args:
- token
# Message to send on command
Message: 'token message'
# Permission for this command
Permission: 'votingplugin.commands.vote.token'
# help message
HelpMessage: 'See tokens'
# Forces player to run this command
Commands:
- tokencommand
##############################################
# Background task settings
##############################################
# Only update in the background when needed when set to false
AlwaysUpdate: false
# Update in the background only if players are online
UpdateWithPlayersOnlineOnly: false
# Delay between background updates like signs and more
# Default: 3 Minutes
# Longer times result in longer wait in stuff updating after a vote, like topvoter
DelayBetweenUpdates: 3
# Enable to true for extra player checks
# Recommend leaving this to false
ExtraBackgroundUpdate: false
# Limit number of users to load in a second
# Effects background tasks mainly
# set to -1 to disable (default value)
#PlayerDataLoadLimit: 500
##########################################
# Inventory controls
##########################################
# Click sound when using gui
# Set to none for no sound
ClickSound:
Sound: 'UI_BUTTON_CLICK'
Volume: 1.0
Pitch: 1.0
# If true, items given for rewards are dropped on the ground
# If false, items will be given when there is space
DropOnFullInv: true
# 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'
# ###############################################################
# Deprecated options, don't recommend using any of these
# Will force GUI's to close on every click
AlwaysCloseInventory: false
# Close inventory on player vote
# This is to prevent any possible exploits
CloseInventoryOnVote: true
###########################################
# Purge settings
###########################################
# Remove old player files
# Happens on startup or /av purge
PurgeOldData: false
# Minimum number of days offline in order to purge
PurgeMin: 90
##########################################
# Extra options
# Options below don't need to be touched
##########################################
# Options for request api
# Current methods:
# ANVIL
@@ -616,9 +696,3 @@ RequestAPI:
DefaultMethod: 'Anvil'
DisabledMethods: []
# Shouldn't need to change this
#AutoKillInvs: true
# Disable checking on world change
# May improve performance
#DisableCheckOnWorldChange: false
+11 -2
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?)
@@ -78,8 +79,8 @@ CHEST:
# Name: 'Extra item'
## Works on most GUI items
# Slot: 10
## Send rewards on click, run commands, check conditions, etc
# Rewards: []
## Send rewards on click, run commands, check conditions, etc
# Rewards: []
# GUI for /vote url, /vote
VoteURL:
@@ -119,8 +120,10 @@ CHEST:
Material: 'EMERALD_BLOCK'
Data: 0
Amount: 1
# URL when clicking item in /vote (GUI version)
URLText: '%VoteUrl%'
# #Add Extra items
# This extra item format works across other gui settings below
# ExtraItems:
# Item1:
# Material: DIRT
@@ -132,6 +135,11 @@ CHEST:
VoteLast:
Name: 'VoteLast: %player%'
BackButton: true
# Lines for each vote site
# %time% = time, using timeformat below
# %timesince% = time since vote
Line: '&6%timeSince%'
ClickableLinks: true
VoteNext:
Name: 'VoteNext: %player%'
BackButton: true
@@ -198,6 +206,7 @@ CHEST:
Amount: 1
VoteBest:
Name: 'VoteBest: %player%'
BackButton: true
DayBest:
Item:
Material: 'CLOCK'
+47 -12
View File
@@ -1,23 +1,38 @@
# 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
# One time reward for voting on all sites in one day
# Enable ExtraAllSitesCheck if you get double rewards
AllSites:
Messages:
Player: '&aYou voted on all sites in 1 day!'
# Give a reward for voting on all sites minus 1
# Similar to allsites
#AlmostAllSites:
# Messages:
# Player: '&aYou almost voted on all sites in 1 day!'
# If true only cumulative reward at a time can be given
# The cumulative rewards will go in order as listed under Cumulative, so if true
# the first cumulative (in the order as listed) that can be given will, then will ignore the rest
OnlyOneCumulative: false
# NOTE: This is not a 1 time reward, that's what milestones are for!
# If total votes (Can be changed) divided by cumulative amount
# and as no remainder (So divides perfectly)then a reward is given
# and with no remainder (So divides perfectly) then a reward is given
Cumulative:
# Number of votes required
# Allows multiple cumulative rewards
@@ -25,12 +40,20 @@ Cumulative:
# Can have multiple listed here
'20':
Enabled: false
# Wether or not votes must be made in same day/week
# Whether 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
# Blacklist recurring votes
#BlackList:
#- 40
# Whether or not to gives cumulative reward for every x number of votes, default: true
#Recurring: true
Rewards:
Messages:
Player: '&aYou got %cumulative% cumulative votes!'
@@ -47,6 +70,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
@@ -55,6 +81,8 @@ VoteParty:
ResetMonthly: false
# If true, will give voteparty only once per day
OnlyOncePerDay: false
# If true, will give voteparty once per week only
OnlyOncePerWeek: false
# Reset extra votes
ResetExtraVotesMonthly: false
# Count votes from /av vote?
@@ -67,7 +95,7 @@ VoteParty:
Broadcast: '&cReached the vote party amount!'
# List of commands to execute, these only execute once.
# %player% does not work here
Commands: []
GlobalCommands: []
# Rewards to give per player
Rewards:
# Uncomment below for online players to be rewarded only
@@ -136,8 +164,10 @@ VoteStreak:
Week: 50
Month: 50
# Reward given when vote cooldown ended
# Using this is a little memory intensive
# 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
@@ -157,6 +187,11 @@ LogoutRewards: {}
EnableMonthlyAwards: true
# TopVoter Placeholders:
#%place% - place in topvoter
#%topvoter% - topvoter type
#%votes% - current total votes related to top voter
# Rewards to give
MonthlyAwards:
# Position. 1 is first in top voter, 2 is second, etc...
+9 -2
View File
@@ -2,6 +2,7 @@ VoteSites:
# VoteSite key
# Used for saving data for votesites
# Use a short name if you can
# No spaces or dots
ExampleVoteSite:
# Enable voteSite
# If false, votesite will not be loaded by plugin
@@ -26,7 +27,7 @@ VoteSites:
ServiceSite: 'PlanetMinecraft.com'
# vote url for /vote
# Format for this can be set in Format.yml
# Format for this can be set in Config.yml
# Do not include colors here
# If you need to force a url set the url as this:
# VoteURL: '[Text="ANY TEXT TO CLICK ON HERE",url="URLHERE"]'
@@ -60,9 +61,15 @@ VoteSites:
DisplayItem:
Material: 'DIAMOND'
Amount: 1
# Reward to run when cooldown ends for this votesite
# Enable PerSiteCoolDownEvents in Config.yml to use this
#CoolDownEndRewards:
# Messages:
# Player: '&aTime to go vote on site1'
# Rewards to give
# https://github.com/Ben12345rocks/AdvancedCore/wiki/Rewards
# https://github.com/BenCodez/AdvancedCore/wiki/Rewards
Rewards:
# Execute console commands
Commands:
+3 -1
View File
@@ -1,4 +1,6 @@
name: ${project.name}
version: ${project.version}
main: com.bencodez.votingplugin.bungee.VotingPluginBungee
author: BenCodez
author: BenCodez
softDepends:
- RedisBungee
+123 -36
View File
@@ -11,30 +11,80 @@ Username: ''
Password: ''
# Max number of connections
MaxConnections: 1
# Maxium size of caching mysql
# -1 for no limit
# Affecting this value may affect performance
MaxSize: -1
# Table name prefix, for use with mutliple servers
# Don't use with PLUGINMESSAGING bungee setup
Prefix: ''
#UseSSL: true
#PublicKeyRetrieval: false
#Attempt to use mariadb driver
#UseMariaDB: false
# Online mode for UUIDS
# Offline mode setups are not fully tested and are not supported currently
OnlineMode: true
####################################################################################
# Global mysql data handle for between server commmunications
# This is NOT required for bungee voting to work
# This is still a WIP, use with caution
# This will create a different table then from users storing server info to process
#
# If you use this you need to enable this on BungeeSettings.yml on each server with votingplugin
# Make sure server name is set correctly in BungeeSettings.yml or this will not work correctly
#
# Please use PLUGINMESSAGING for this, SOCKETS should work as well, but not fully tested
#
# This will make votes cache until time change has finished processing
# In the event a server is offline or time change fails, the time change process
# will continue after a set amount of time (in essense skipping a specific server)
# This will also respect blocked servers
GlobalData:
Enabled: false
# Use existing connection above
UseMainMySQL: true
# Mysql settings only used if above is false
Host: ''
# Default port is 3306
Port: 3306
Database: ''
Username: ''
Password: ''
# Max number of connections
MaxConnections: 1
# Must be the same on all servers
Prefix: ''
#UseSSL: true
#PublicKeyRetrieval: false
#Attempt to use mariadb driver
#UseMariaDB: false
# Time offset for time changes
# Must match on all servers
TimeHourOffSet: 0
####################################################################################
Debug: false
# Have a reward on each server
# If false, will send to online server only
SendVotesToAllServers: true
# List of servers the plugin won't send the vote to
# Uses names from bungeecoord config if not using SOCKETS method
# Uses names from bungeecoord config, only needed for non SOCKETS setup
BlockedServers:
- hub
# Similar to BlockServers
# If a server is listed then blockedservers is ignored
WhiteListedServers: []
# 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
# PLUGINMESSAGING (Recommended)
# MYSQL
BungeeMethod: PLUGINMESSAGING
@@ -43,43 +93,80 @@ BungeeMethod: PLUGINMESSAGING
# This requires spigot servers AllowUnJoined to be set to true in Config.yml
AllowUnJoined: false
# Points to give on vote
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
# If false, AllowUnJoined should be enabled on bungee, spigot servers will handle that
# Recommeneded to leave enabled, setups with this disabled are currently unsupported
BungeeManageTotals: true
# ----------------------------
# PLUGINMESSAGING Settings
# ----------------------------
# Tell servers to broadcast
# Set DisableBroadcast to true on spigot servers (BungeeSettings.yml) as well
Broadcast: true
# Applies to PLUGINMESSAGING & when SendVotesToAllServers is true
# Geyser settings
# This may or may not work
# Does not work on velocity currently
GeyserSupport: false
GeyserPrefix: '.'
VoteParty:
# If enabled, will trigger vote party reward
# in BungeeSettings.yml under BungeeVotePartyReward
# Only runs rewards for online players
Enabled: false
# Votes required
VotesRequired: 100
# Increase amount required on each vote party
IncreaseVotesRequired: 0
# If false, will only send to servers listed below
SendToAllServers: true
# Servers to send to, if SendToAllServers is false
ServersToSend: []
# List of commands to run on bungee server
# Set spigot commands in BungeeSettings.yml
BungeeCommands: []
Broadcast: '&aVote party has been reached!'
##########################################
# PLUGINMESSAGING Settings
##########################################
# Applies to PLUGINMESSAGING only
# 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
##########################################
# Multi-proxy setup
# This is still a WIP, use with caution
# Primary server needs votifier and config option enabled
# Set socket host on each proxy and primary server set sub proxies
# All servers should be on pluginmessaging or sockets setup
##########################################
# Server to send vote to if player is offline
FallBackServer: factions
# Support for redis
# experimental
MultiProxySupport: false
# Bungee communication, Add this to each spigot server
# For socket method
BungeeServer:
Host: '127.0.0.1'
Port: 1297
# Bungee communication, add each spigot server here
# For socket method
SpigotServers:
lobby:
Host: '127.0.0.1'
Port: 1298
factions:
Host: '127.0.0.1'
Port: 1999
# Enable on primary proxy server with votifier
PrimaryServer: false
# If enabled, player will only get 1 reward on a server on the network
# Must be enabled on all proxies for this to work
# Must also disable sendtoallservers
MultiProxyOneGlobalReward: false
# Set this for each proxy
MultiProxySocketHost:
Host: 0.0.0.0
Port: 1234
# Set other sub proxies here
MultiProxyServers:
secondproxy:
Host: 0.0.0.0
Port: 1235
+270 -250
View File
@@ -1,250 +1,270 @@
name: ${project.name}
version: ${project.version}
main: com.bencodez.votingplugin.VotingPluginMain
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]
api-version: 1.13
commands:
vote:
description: Vote command
adminvote:
description: Admin commands for VotingPlugin
av:
description: Admin commands for VotingPlugin
votehelp:
description: See access to a list of commands, Formated in Format.yml
aliases: vhelp
votetotal:
description: See totals of votes
aliases: vtotal
votelast:
description: See the last time you voted
aliases: vlast
votenext:
description: See when you can vote next
aliases: vnext
votetop:
description: See top voters
aliases: vtop
votetoday:
description: See who voted today
aliases: vtoday
votegui:
description: Open VoteGUI
aliases: vgui
voteurl:
description: Open VoteURL
aliases: vurl
votereward:
description: Open VoteReward GUI
aliases: vreward
vote?:
description: View Help
aliases: v?
voteparty:
description: A command
aliases: vparty
voteshop:
description: A command
aliases: vshop
votebest:
description: A command
aliases: vbest
votestreak:
description: A command
aliases: vstreak
votetogglebroadcast:
description: A command
aliases: vtogglebroadcast
votepoints:
description: A command
aliases: vpoints
votelist:
description: A command
aliases: vlist
voteall:
description: A command
aliases: vall
votechoices:
description: A command
alaises: vchoices
votegivepoints:
description: A command
alaises: vgivepoints
adminvotehelp:
description: Open adminvote help
aliases: avhelp
adminvote?:
description: Open adminvote help
aliases: av?
adminvotereport:
description: Command Alias
aliases: avreport
adminvoteperms:
description: Command Alias
aliases: avperms
adminvoteDownload:
description: Command Alias
aliases: avdownload
adminvotereload:
description: Command Alias
aliases: avreload
adminvotetestreward:
description: Command Alias
aliases: avtestreward
adminvoteversion:
description: Command Alias
aliases: avversion
adminvotesites:
description: Command Alias
aliases: avsites
adminvoterewards:
description: Command Alias
aliases: avrewards
adminvoteuuid:
description: Command Alias
aliases: avuuid
adminvotevotesite:
description: Command Alias
aliases: avvotesite
adminvoteconfig:
description: Command Alias
aliases: avconfig
adminvoteupdatecheck:
description: Command Alias
aliases: avupdatecheck
adminvotevote:
description: Command Alias
aliases: [avvote, fakevote]
adminvotegui:
description: Command Alias
aliases: avgui
adminvotegivereward:
description: Command Alias
aliases: avgivereward
adminvoteConvertFromData:
description: Command Alias
aliases: avConvertFromData
adminvoteClearTotal:
description: Command Alias
adminvoteBackgroundUpdate:
description: Command Alias
aliases: avBackgroundUpdate
adminvoteClearCache:
description: Command Alias
aliases: avClearCache
adminvoteServiceSites:
description: Command Alias
aliases: avServiceSites
adminvoteSetVotePartyCount:
description: Command Alias
aliases: avSetVotePartyCount
adminvoteChoices:
description: Command Alias
aliases: avChoices
adminvoteReloadAll:
description: Command Alias
aliases: avReloadAll
adminvotePermsPlayer:
description: Command Alias
aliases: avPermsPlayer
adminvoteResyncMilestonesAlreadyGiven:
description: Command Alias
aliases: avResyncMilestonesAlreadyGiven
voteSetPrimaryAccount:
description: Command Alias
adminvoteClearOfflineVotes:
description: Command Alias
aliases: avClearOfflineVotes
adminvoteGiveAll:
description: Command Alias
aliases: avGiveAll
adminvoteGiveAllOnline:
description: Command Alias
aliases: avGiveAllOnline
adminvoteForceTimeChanged:
description: Command Alias
aliases: avForceTimeChanged
adminvoteplayername:
description: Command Alias
aliases: avplayername
adminvoteResyncMilestones:
description: Command Alias
aliases: avResyncMilestones
adminvoteClearOfflineRewards:
description: Command Alias
aliases: avClearOfflineRewards
adminvoteUserRemove:
description: Command Alias
aliases: avUserRemove
adminvotePurge:
description: Command Alias
aliases: avPurge
adminvoteJavascript:
description: Command Alias
aliases: avJavascript
adminvoteStatus:
description: Command Alias
aliases: avStatus
adminvoteTest:
description: Command Alias
aliases: avTest
adminvotePlaceholders:
description: Command Alias
aliases: avPlaceholders
adminvoteDownloadJenkins:
description: Command Alias
aliases: avDownloadJenkins
adminvoteForceVoteParty:
description: Command Alias
aliases: avForceVoteParty
adminvoteSetRequestMethod:
description: Command Alias
aliases: avSetRequestMethod
adminvoteUser:
description: Command Alias
aliases: avUser
adminvoteCurrentPluginTime:
description: Command Alias
aliases: avCurrentPluginTime
adminvoteResetPoints:
description: Command Alias
aliases: avResetPoints
adminvoteVotePartyExtraRequired:
description: Command Alias
aliases: avVotePartyExtraRequired
adminvoteRunCMD:
description: Command Alias
aliases: avRunCMD
permissions:
VotingPlugin.Player:
description: Allows basic access player commands
VotingPlugin.Mod:
description: Allows mod commands
VotingPlugin.Admin:
description: Allows admincommands
VotingPlugin.Login.RemindVotes:
description: Allows players to get remined on login if they can vote
default: true
VotingPlugin.Admin.Debug:
description: Permission to view debug info ingame
VotingPlugin.Signs.Create:
description: Allows access to create signs
VotingPlugin.TopVoter.Ignore:
description: Allows you to be exempt from top voter
VotingPlugin.NoRemind:
description: Ignore vote reminding
default: false
VotingPlugin.Sign.Create:
description: Permission to create sign
VotingPlugin.Admin.GenerateServiceSite:
description: Permission for generating votesite message
VotingPlugin.Login.RemindVotes:
description: Permission to allow timed reminders
VotingPlugin.Login.RemindVotes.Any:
description: Remind if player can vote on any website, rather than all
default: false
name: ${project.name}
version: ${project.version}
main: com.bencodez.votingplugin.VotingPluginMain
description: Highly Customizable Voting Listener!
website: https://www.spigotmc.org/resources/votingplugin.15358/
author: BenCodez
softdepend:
- MVdWPlaceholders
- Votifier
- VotifierPlus
- NuVotifier
- Vault
- PlaceholderAPI
- ProtocolLib
- MVdWPlaceholderAPI
- AuthMe
- SuperVanish
- PremiumVanish
- DiscordSRV
loadbefore:
- MCPerks
api-version: 1.13
libraries:
- org.openjdk.nashorn:nashorn-core:15.3
commands:
vote:
description: Vote command
adminvote:
description: Admin commands for VotingPlugin
av:
description: Admin commands for VotingPlugin
votehelp:
description: See access to a list of commands, Formated in Format.yml
aliases: vhelp
votetotal:
description: See totals of votes
aliases: vtotal
votelast:
description: See the last time you voted
aliases: vlast
votenext:
description: See when you can vote next
aliases: vnext
votetop:
description: See top voters
aliases: vtop
votetoday:
description: See who voted today
aliases: vtoday
votegui:
description: Open VoteGUI
aliases: vgui
voteurl:
description: Open VoteURL
aliases: vurl
votereward:
description: Open VoteReward GUI
aliases: vreward
vote?:
description: View Help
aliases: v?
voteparty:
description: A command
aliases: vparty
voteshop:
description: A command
aliases: vshop
votebest:
description: A command
aliases: vbest
votestreak:
description: A command
aliases: vstreak
votetogglebroadcast:
description: A command
aliases: vtogglebroadcast
votepoints:
description: A command
aliases: vpoints
votetogglereminders:
aliases:
- vtogglereminder
- vtoggle
votelist:
description: A command
aliases: vlist
voteall:
description: A command
aliases: vall
votechoices:
description: A command
alaises: vchoices
votegivepoints:
description: A command
alaises: vgivepoints
adminvotehelp:
description: Open adminvote help
aliases: avhelp
adminvote?:
description: Open adminvote help
aliases: av?
adminvotereport:
description: Command Alias
aliases: avreport
adminvoteperms:
description: Command Alias
aliases: avperms
adminvotereload:
description: Command Alias
aliases: avreload
adminvotetestreward:
description: Command Alias
aliases: avtestreward
adminvoteversion:
description: Command Alias
aliases: avversion
adminvotesites:
description: Command Alias
aliases: avsites
adminvoterewards:
description: Command Alias
aliases: avrewards
adminvoteuuid:
description: Command Alias
aliases: avuuid
adminvotevotesite:
description: Command Alias
aliases: avvotesite
adminvoteconfig:
description: Command Alias
aliases: avconfig
adminvoteupdatecheck:
description: Command Alias
aliases: avupdatecheck
adminvotevote:
description: Command Alias
aliases:
- avvote
- fakevote
adminvotegui:
description: Command Alias
aliases: avgui
adminvotegivereward:
description: Command Alias
aliases: avgivereward
adminvoteConvertFromData:
description: Command Alias
aliases: avConvertFromData
adminvoteConvertToData:
description: Command Alias
aliases: avConvertFromData
adminvoteClearTotal:
description: Command Alias
adminvoteBackgroundUpdate:
description: Command Alias
aliases: avBackgroundUpdate
adminvoteClearCache:
description: Command Alias
aliases: avClearCache
adminvoteServiceSites:
description: Command Alias
aliases: avServiceSites
adminvoteVoteParty:
description: Command Alias
aliases: avVoteParty
adminvoteChoices:
description: Command Alias
aliases: avChoices
adminvoteReloadAll:
description: Command Alias
aliases: avReloadAll
adminvotePermsPlayer:
description: Command Alias
aliases: avPermsPlayer
adminvoteResyncMilestonesAlreadyGiven:
description: Command Alias
aliases: avResyncMilestonesAlreadyGiven
voteSetPrimaryAccount:
description: Command Alias
adminvoteClearOfflineVotes:
description: Command Alias
aliases: avClearOfflineVotes
adminvoteGiveAll:
description: Command Alias
aliases: avGiveAll
adminvoteGiveAllOnline:
description: Command Alias
aliases: avGiveAllOnline
adminvoteForceTimeChanged:
description: Command Alias
aliases: avForceTimeChanged
adminvoteplayername:
description: Command Alias
aliases: avplayername
adminvoteResyncMilestones:
description: Command Alias
aliases: avResyncMilestones
adminvoteClearOfflineRewards:
description: Command Alias
aliases: avClearOfflineRewards
adminvoteUserRemove:
description: Command Alias
aliases: avUserRemove
adminvotePurge:
description: Command Alias
aliases: avPurge
adminvoteJavascript:
description: Command Alias
aliases: avJavascript
adminvoteStatus:
description: Command Alias
aliases: avStatus
adminvoteTest:
description: Command Alias
aliases: avTest
adminvotePlaceholders:
description: Command Alias
aliases: avPlaceholders
adminvoteDownloadJenkins:
description: Command Alias
aliases: avDownloadJenkins
adminvoteSetRequestMethod:
description: Command Alias
aliases: avSetRequestMethod
adminvoteUser:
description: Command Alias
aliases: avUser
adminvoteCurrentPluginTime:
description: Command Alias
aliases: avCurrentPluginTime
adminvoteResetPoints:
description: Command Alias
aliases: avResetPoints
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
VotingPlugin.Mod:
description: Allows mod commands
VotingPlugin.Admin:
description: Allows admincommands
VotingPlugin.Admin.Debug:
description: Permission to view debug info ingame
VotingPlugin.Signs.Create:
description: Allows access to create signs
VotingPlugin.TopVoter.Ignore:
description: Allows you to be exempt from top voter
VotingPlugin.NoRemind:
description: Ignore vote reminding
default: false
VotingPlugin.Sign.Create:
description: Permission to create sign
VotingPlugin.Admin.GenerateServiceSite:
description: Permission for generating votesite message
VotingPlugin.Login.RemindVotes:
description: Permission to allow timed reminders
VotingPlugin.Login.RemindVotes.All:
description: Remind if player can vote on all votesites, rather than any
default: false
@@ -1,2 +1,4 @@
time: '${timestamp}'
profile: ${build.profile.id}
profile: '${build.profile.id}'
version: '${project.version}'
buildnumber: '${build.number}'
+195 -132
View File
@@ -1,10 +1,8 @@
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.bencodez</groupId>
<artifactId>VotingPlugin</artifactId>
<version>6.3</version>
<artifactId>votingplugin</artifactId>
<version>6.12.1</version>
<packaging>jar</packaging>
<name>VotingPlugin</name>
<properties>
@@ -12,14 +10,8 @@
<maven.compiler.target>1.8</maven.compiler.target>
<github.global.server>github</github.global.server>
<project.build.sourceEncoding>Cp1252</project.build.sourceEncoding>
<build.number>NOTSET</build.number>
</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 +71,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>
@@ -102,15 +94,19 @@
<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>
@@ -128,8 +124,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>
@@ -148,50 +148,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>
@@ -228,7 +194,6 @@
<id>spigot-repo</id>
<url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
</repository>
<repository>
<id>maven-central</id>
<url>https://oss.sonatype.org/content/groups/public</url>
@@ -242,20 +207,15 @@
<url>https://nexus.velocitypowered.com/repository/maven-public/</url>
</repository>
<repository>
<id>bintray-repo</id>
<url>https://dl.bintray.com/ichbinjoe/public/</url>
<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.5-R0.1-SNAPSHOT</version>
<version>1.19.4-R0.1-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
<dependency>
@@ -267,88 +227,191 @@
<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.6.0</version>
<version>2.7.2</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>
</dependency>
<dependency>
<groupId>be.maximvdw</groupId>
<artifactId>MVdWPlaceholderAPI</artifactId>
<artifactId>mvdwplaceholderapi</artifactId>
<version>3.1.1</version>
<scope>provided</scope>
</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>
<dependency>
<groupId>com.bencodez</groupId>
<artifactId>advancedcore</artifactId>
<version>LATEST</version>
<scope>system</scope>
<systemPath>${project.basedir}/Jars/MVdWPlaceholderAPI.jar</systemPath>
<scope>compile</scope>
</dependency>
</dependencies>
<profiles>
<profile>
<id>prod</id>
<activation>
<activeByDefault>true</activeByDefault>
</activation>
<properties>
<build.profile.id>prod</build.profile.id>
</properties>
<dependencies>
<dependency>
<groupId>com.github.bencodez</groupId>
<artifactId>advancedcore</artifactId>
<version>master-SNAPSHOT</version>
</dependency>
</dependencies>
<repositories>
<repository>
<id>jitpack.io</id>
<url>https://jitpack.io</url>
<snapshots>
<enabled>true</enabled>
<updatePolicy>always</updatePolicy>
</snapshots>
</repository>
</repositories>
</profile>
<profile>
<id>prod2</id>
<properties>
<build.profile.id>prod2</build.profile.id>
</properties>
<dependencies>
<dependency>
<groupId>com.bencodez</groupId>
<artifactId>AdvancedCore</artifactId>
<version>LATEST</version>
<scope>compile</scope>
</dependency>
</dependencies>
<distributionManagement>
<repository>
<id>internal.repo</id>
<name>Temporary Staging Repository</name>
<url>file://${project.build.directory}/mvn-repo</url>
</repository>
</distributionManagement>
</profile>
<profile>
<id>dev</id>
<id>deploy-snapshot</id>
<properties>
<build.profile.id>dev</build.profile.id>
<build.profile.id>deploy-snapshot</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-snapshots/</url>
</repository>
</distributionManagement>
<build>
<plugins>
<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>
</plugins>
</build>
</profile>
<profile>
<id>deploy</id>
<properties>
<build.profile.id>deploy</build.profile.id>
</properties>
<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);
}
}
@@ -1,10 +1,29 @@
package com.bencodez.votingplugin;
import java.io.File;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.UUID;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.Listener;
import com.bencodez.advancedcore.api.misc.MiscUtils;
import com.bencodez.advancedcore.api.misc.encryption.EncryptionHandler;
import com.bencodez.advancedcore.api.rewards.RewardBuilder;
import com.bencodez.advancedcore.api.time.TimeType;
import com.bencodez.advancedcore.api.user.UserStorage;
import com.bencodez.advancedcore.api.user.usercache.value.DataValue;
import com.bencodez.advancedcore.api.user.usercache.value.DataValueBoolean;
import com.bencodez.advancedcore.api.user.userstorage.mysql.api.config.MysqlConfigSpigot;
import com.bencodez.advancedcore.bungeeapi.globaldata.GlobalDataHandler;
import com.bencodez.advancedcore.bungeeapi.globaldata.GlobalMySQL;
import com.bencodez.advancedcore.bungeeapi.pluginmessage.PluginMessageHandler;
import com.bencodez.advancedcore.bungeeapi.sockets.ClientHandler;
import com.bencodez.advancedcore.bungeeapi.sockets.SocketHandler;
@@ -18,7 +37,7 @@ import com.bencodez.votingplugin.user.VotingPluginUser;
import lombok.Getter;
public class BungeeHandler {
public class BungeeHandler implements Listener {
@Getter
private ClientHandler clientHandler;
@@ -29,16 +48,209 @@ public class BungeeHandler {
private VotingPluginMain plugin;
@Getter
private int bungeeVotePartyCurrent = 0;
@Getter
private int bungeeVotePartyRequired = 0;
@Getter
private SocketHandler socketHandler;
private GlobalDataHandler globalDataHandler;
@Getter
private ScheduledExecutorService timer;
public BungeeHandler(VotingPluginMain plugin) {
this.plugin = plugin;
}
public void close() {
socketHandler.closeConnection();
clientHandler.stopConnection();
if (socketHandler != null) {
socketHandler.closeConnection();
}
if (clientHandler != null) {
clientHandler.stopConnection();
}
plugin.getServerData().setBungeeVotePartyCurrent(bungeeVotePartyCurrent);
plugin.getServerData().setBungeeVotePartyRequired(bungeeVotePartyRequired);
if (globalDataHandler != null) {
globalDataHandler.getGlobalMysql().close();
}
}
/*
* @EventHandler public void onDateChange(DateChangedEvent event) { if
* (method.equals(BungeeMethod.PLUGINMESSAGING)) {
* plugin.getPluginMessaging().sendPluginMessage("timeupdate",
* plugin.getServerDataFile().getPrevMonth() + "//" +
* plugin.getServerDataFile().getPrevDay() + "//" +
* plugin.getServerDataFile().getPrevWeekDay()); } }
*/
public void checkGlobalData() {
HashMap<String, DataValue> data = globalDataHandler.getExact(plugin.getBungeeSettings().getServer());
// plugin.debug(data.toString());
if (data.containsKey("ForceUpdate")) {
boolean b = checkGlobalDataTimeValue(data.get("ForceUpdate"));
if (b) {
if (plugin.getStorageType().equals(UserStorage.MYSQL)) {
plugin.getMysql().clearCacheBasic();
}
plugin.getUserManager().getDataManager().clearCache();
plugin.setUpdate(true);
plugin.update();
globalDataHandler.setBoolean(plugin.getBungeeSettings().getServer(), "ForceUpdate", false);
}
}
boolean forceUpdate = false;
if (checkGlobalDataTime(TimeType.MONTH, data)) {
forceUpdate = true;
}
if (checkGlobalDataTime(TimeType.WEEK, data)) {
forceUpdate = true;
}
if (checkGlobalDataTime(TimeType.DAY, data)) {
forceUpdate = true;
}
if (forceUpdate) {
HashMap<String, DataValue> dataToSet = new HashMap<String, DataValue>();
dataToSet.put("FinishedProcessing", new DataValueBoolean(true));
dataToSet.put("Processing", new DataValueBoolean(false));
globalDataHandler.setData(plugin.getBungeeSettings().getServer(), dataToSet);
}
}
public boolean checkGlobalDataTimeValue(DataValue data) {
if (data.isBoolean()) {
return data.getBoolean();
}
return Boolean.valueOf(data.getString());
}
public boolean checkGlobalDataTime(TimeType type, HashMap<String, DataValue> data) {
boolean isProcessing = false;
if (data.containsKey(type.toString())) {
DataValue value = data.get(type.toString());
boolean b = checkGlobalDataTimeValue(value);
if (b) {
long lastUpdated = Long.valueOf(data.get("LastUpdated").getString()).longValue();
plugin.debug("LastUpdated: " + lastUpdated);
if (LocalDateTime.now().atZone(ZoneOffset.UTC).toInstant().toEpochMilli() - lastUpdated > 1000 * 60 * 60
* 1) {
plugin.getLogger().warning("Ignore bungee time change since it was more than 1 hour ago");
return false;
}
globalDataHandler.setBoolean(plugin.getBungeeSettings().getServer(), "Processing", true);
isProcessing = true;
plugin.debug("Detected time change from bungee: " + type.toString());
plugin.getTimeChecker().forceChanged(type, false, true, true);
globalDataHandler.setBoolean(plugin.getBungeeSettings().getServer(), type.toString(), false);
}
}
return isProcessing;
}
public void loadGlobalMysql() {
if (plugin.getBungeeSettings().isGloblalDataEnabled()) {
if (timer != null) {
timer.shutdown();
try {
timer.awaitTermination(5, TimeUnit.SECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
timer.shutdownNow();
}
timer = Executors.newScheduledThreadPool(1);
timer.scheduleWithFixedDelay(new Runnable() {
@Override
public void run() {
checkGlobalData();
}
}, 60, 10, TimeUnit.SECONDS);
timer.scheduleWithFixedDelay(new Runnable() {
@Override
public void run() {
globalDataHandler.setString(plugin.getBungeeSettings().getServer(), "LastOnline",
"" + LocalDateTime.now().atZone(ZoneOffset.UTC).toInstant().toEpochMilli());
}
}, 1, 60, TimeUnit.MINUTES);
if (globalDataHandler != null) {
globalDataHandler.getGlobalMysql().close();
}
if (plugin.getBungeeSettings().isGloblalDataUseMainMySQL()
&& plugin.getStorageType().equals(UserStorage.MYSQL)) {
globalDataHandler = new GlobalDataHandler(
new GlobalMySQL("VotingPlugin_GlobalData", plugin.getMysql().getMysql()) {
@Override
public void warning(String text) {
plugin.getLogger().warning(text);
}
@Override
public void severe(String text) {
plugin.getLogger().severe(text);
}
@Override
public void debug(Exception e) {
plugin.debug(e);
}
@Override
public void debug(String text) {
plugin.debug(text);
}
});
} else {
globalDataHandler = new GlobalDataHandler(
new GlobalMySQL("VotingPlugin_GlobalData", new MysqlConfigSpigot(
plugin.getBungeeSettings().getData().getConfigurationSection("GlobalData"))) {
@Override
public void warning(String text) {
plugin.getLogger().warning(text);
}
@Override
public void severe(String text) {
plugin.getLogger().severe(text);
}
@Override
public void debug(Exception e) {
plugin.debug(e);
}
@Override
public void debug(String text) {
plugin.debug(text);
}
});
}
globalDataHandler.getGlobalMysql().alterColumnType("IgnoreTime", "VARCHAR(5)");
globalDataHandler.getGlobalMysql().alterColumnType("MONTH", "VARCHAR(5)");
globalDataHandler.getGlobalMysql().alterColumnType("WEEK", "VARCHAR(5)");
globalDataHandler.getGlobalMysql().alterColumnType("DAY", "VARCHAR(5)");
globalDataHandler.getGlobalMysql().alterColumnType("FinishedProcessing", "VARCHAR(5)");
globalDataHandler.getGlobalMysql().alterColumnType("Processing", "VARCHAR(5)");
globalDataHandler.getGlobalMysql().alterColumnType("LastUpdated", "MEDIUMTEXT");
globalDataHandler.getGlobalMysql().alterColumnType("ForceUpdate", "VARCHAR(5)");
plugin.getTimeChecker().setProcessingEnabled(false);
}
}
public void load() {
@@ -48,11 +260,18 @@ public class BungeeHandler {
plugin.getLogger().info("Using BungeeMethod: " + method.toString());
loadGlobalMysql();
if (method.equals(BungeeMethod.MYSQL)) {
plugin.registerBungeeChannels("vp:vp");
} else if (method.equals(BungeeMethod.PLUGINMESSAGING)) {
plugin.registerBungeeChannels("vp:vp");
bungeeVotePartyCurrent = plugin.getServerData().getBungeeVotePartyCurrent();
bungeeVotePartyRequired = plugin.getServerData().getBungeeVotePartyRequired();
plugin.getPluginMessaging().setDebug(plugin.getBungeeSettings().isBungeeDebug());
plugin.getPluginMessaging().add(new PluginMessageHandler("Vote") {
@Override
public void onRecieve(String subChannel, ArrayList<String> args) {
@@ -75,21 +294,60 @@ public class BungeeHandler {
BungeeMessageData text = new BungeeMessageData(args.get(6));
bungeeVotePartyCurrent = text.getVotePartyCurrent();
bungeeVotePartyRequired = text.getVotePartyRequired();
plugin.getPlaceholders().onBungeeVotePartyUpdate();
plugin.getServerData().setBungeeVotePartyCurrent(bungeeVotePartyCurrent);
plugin.getServerData().setBungeeVotePartyRequired(bungeeVotePartyRequired);
boolean setTotals = Boolean.valueOf(args.get(7));
user.clearCache();
user.bungeeVotePluginMessaging(service, time, text, !setTotals, wasOnline);
boolean broadcast = true;
boolean bungeeBroadcast = false;
if (args.size() > 9) {
bungeeBroadcast = Boolean.valueOf(args.get(9));
}
int num = 1;
if (args.size() > 10) {
num = Integer.valueOf(args.get(10));
}
int numberOfVotes = 1;
if (args.size() > 11) {
numberOfVotes = Integer.valueOf(args.get(11));
}
if (!bungeeBroadcast) {
if (!plugin.getBungeeSettings().isBungeeBroadcast()
&& !plugin.getBungeeSettings().isDisableBroadcast()) {
if (wasOnline || plugin.getBungeeSettings().isBungeeBroadcastAlways()) {
if (plugin.getConfigFile().isFormatOnlyOneOfflineBroadcast() && !wasOnline) {
if (num == 1) {
user.offlineBroadcast(user, plugin.getBungeeSettings().isUseBungeecoord(),
numberOfVotes);
}
} else {
VoteSite site = plugin.getVoteSite(service, true);
if (site != null) {
site.broadcastVote(user, false);
broadcast = false;
} else {
plugin.getLogger().warning("No votesite for " + service);
}
}
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);
}
}
} else {
broadcast = false;
}
user.bungeeVotePluginMessaging(service, time, text, !setTotals, wasOnline, broadcast, num);
if (plugin.getBungeeSettings().isPerServerPoints()) {
user.addPoints(plugin.getConfigFile().getPointsOnVote());
}
if (Boolean.valueOf(args.get(5))) {
@@ -116,27 +374,72 @@ public class BungeeHandler {
String service = args.get(2);
long time = Long.parseLong(args.get(3));
BungeeMessageData text = new BungeeMessageData(args.get(6));
bungeeVotePartyCurrent = text.getVotePartyCurrent();
bungeeVotePartyRequired = text.getVotePartyRequired();
plugin.getPlaceholders().onBungeeVotePartyUpdate();
plugin.getServerData().setBungeeVotePartyCurrent(bungeeVotePartyCurrent);
plugin.getServerData().setBungeeVotePartyRequired(bungeeVotePartyRequired);
plugin.debug(
"pluginmessaging voteonline received from " + player + "/" + uuid + " on " + service);
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(UUID.fromString(uuid),
player);
user.clearCache();
if (plugin.getBungeeSettings().isPerServerPoints()) {
user.addPoints(plugin.getConfigFile().getPointsOnVote());
}
boolean setTotals = Boolean.valueOf(args.get(7));
boolean wasOnline = Boolean.valueOf(args.get(4));
user.bungeeVotePluginMessaging(service, time, text, !setTotals, wasOnline);
boolean broadcast = true;
boolean bungeeBroadcast = false;
if (args.size() > 9) {
bungeeBroadcast = Boolean.valueOf(args.get(9));
}
int num = 1;
if (args.size() > 10) {
num = Integer.valueOf(args.get(10));
}
int numberOfVotes = 1;
if (args.size() > 11) {
numberOfVotes = Integer.valueOf(args.get(11));
}
if (!bungeeBroadcast) {
if (!plugin.getBungeeSettings().isBungeeBroadcast()
&& !plugin.getBungeeSettings().isDisableBroadcast()) {
if (wasOnline || plugin.getBungeeSettings().isBungeeBroadcastAlways()) {
if (plugin.getConfigFile().isFormatOnlyOneOfflineBroadcast() && !wasOnline) {
if (num == 1) {
user.offlineBroadcast(user, plugin.getBungeeSettings().isUseBungeecoord(),
numberOfVotes);
}
} else {
VoteSite site = plugin.getVoteSite(service, true);
if (site != null) {
site.broadcastVote(user, false);
broadcast = false;
} else {
plugin.getLogger().warning("No votesite for " + service);
}
}
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);
}
}
} else {
broadcast = false;
}
user.bungeeVotePluginMessaging(service, time, text, !setTotals, wasOnline, broadcast, num);
if (plugin.getBungeeSettings().isPerServerPoints()) {
user.addPoints(plugin.getConfigFile().getPointsOnVote());
}
if (Boolean.valueOf(args.get(5))) {
@@ -158,21 +461,51 @@ public class BungeeHandler {
user.offVote();
if (args.size() > 2) {
bungeeVotePartyCurrent = Integer.parseInt(args.get(1));
bungeeVotePartyRequired = Integer.parseInt(args.get(2));
plugin.getServerData().setBungeeVotePartyCurrent(bungeeVotePartyCurrent);
plugin.getServerData().setBungeeVotePartyRequired(bungeeVotePartyRequired);
}
plugin.setUpdate(true);
}
});
plugin.getPluginMessaging().add(new PluginMessageHandler("BungeeTimeChange") {
@Override
public void onRecieve(String subChannel, ArrayList<String> args) {
checkGlobalData();
}
});
plugin.getPluginMessaging().add(new PluginMessageHandler("VoteBroadcast") {
@Override
public void onRecieve(String subChannel, ArrayList<String> args) {
String uuid = args.get(0);
String service = args.get(1);
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(UUID.fromString(uuid));
VoteSite site = plugin.getVoteSite(service);
if (site != null) {
site.broadcastVote(user, false);
} else {
plugin.getLogger().warning("No votesite for " + service);
if (args.size() > 2) {
String uuid = args.get(0);
String service = args.get(2);
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(UUID.fromString(uuid),
args.get(1));
VoteSite site = plugin.getVoteSite(service, true);
if (site != null) {
site.broadcastVote(user, false);
} else {
plugin.getLogger().warning("No votesite for " + service);
}
}
}
});
plugin.getPluginMessaging().add(new PluginMessageHandler("VoteBroadcastOffline") {
@Override
public void onRecieve(String subChannel, ArrayList<String> args) {
if (args.size() > 2) {
String uuid = args.get(0);
String votes = args.get(2);
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(UUID.fromString(uuid),
args.get(1));
user.offlineBroadcast(user, false, Integer.parseInt(votes));
}
}
});
@@ -186,6 +519,33 @@ public class BungeeHandler {
}
});
plugin.getPluginMessaging().add(new PluginMessageHandler("VotePartyBungee") {
@Override
public void onRecieve(String subChannel, ArrayList<String> args) {
for (final String cmd : plugin.getBungeeSettings().getBungeeVotePartyGlobalCommands()) {
Bukkit.getScheduler().runTask(plugin, new Runnable() {
@Override
public void run() {
Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), cmd);
}
});
}
for (Player p : Bukkit.getOnlinePlayers()) {
new RewardBuilder(plugin.getBungeeSettings().getData(), "BungeeVotePartyRewards").send(p);
}
}
});
plugin.getPluginMessaging().add(new PluginMessageHandler("VotePartyBroadcast") {
@Override
public void onRecieve(String subChannel, ArrayList<String> args) {
String broadcast = args.get(0);
MiscUtils.getInstance().broadcast(broadcast);
}
});
} else if (method.equals(BungeeMethod.SOCKETS)) {
encryptionHandler = new EncryptionHandler(new File(plugin.getDataFolder(), "secretkey.key"));
@@ -195,7 +555,13 @@ public class BungeeHandler {
socketHandler = new SocketHandler(plugin.getVersion(), plugin.getBungeeSettings().getSpigotServerHost(),
plugin.getBungeeSettings().getSpigotServerPort(), encryptionHandler,
plugin.getBungeeSettings().isBungeeDebug());
plugin.getBungeeSettings().isBungeeDebug()) {
@Override
public void log(String str) {
plugin.getLogger().info(str);
}
};
socketHandler.add(new SocketReceiver("bungeevote") {
@@ -213,11 +579,23 @@ public class BungeeHandler {
user.clearCache();
if (plugin.getBungeeSettings().isPerServerPoints()) {
user.addPoints(plugin.getConfigFile().getPointsOnVote());
}
user.bungeeVote(data[3], new BungeeMessageData(data[4]), !Boolean.valueOf(data[5]));
}
}
});
socketHandler.add(new SocketReceiver("BungeeTimeChange") {
@Override
public void onReceive(String[] data) {
checkGlobalData();
}
});
socketHandler.add(new SocketReceiver("bungeevoteonline") {
@Override
@@ -234,17 +612,34 @@ public class BungeeHandler {
user.clearCache();
if (plugin.getBungeeSettings().isPerServerPoints()) {
user.addPoints(plugin.getConfigFile().getPointsOnVote());
}
user.bungeeVoteOnline(data[3], new BungeeMessageData(data[4]), !Boolean.valueOf(data[5]));
}
}
});
socketHandler.add(new SocketReceiver("BroadcastOffline") {
@Override
public void onReceive(String[] data) {
if (data.length > 2) {
String votes = data[0];
String p = data[1];
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(p);
user.offlineBroadcast(user, false, Integer.parseInt(votes));
}
}
});
socketHandler.add(new SocketReceiver("BungeeBroadcast") {
@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) {
@@ -256,6 +651,23 @@ public class BungeeHandler {
}
});
socketHandler.add(new SocketReceiver("Broadcast") {
@Override
public void onReceive(String[] data) {
if (data.length > 2) {
VoteSite site = plugin.getVoteSite(data[1], true);
String p = data[2];
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(p);
if (site != null) {
site.broadcastVote(user, false);
} else {
plugin.getLogger().warning("No votesite for " + data[1]);
}
}
}
});
socketHandler.add(new SocketReceiver("Status") {
@Override
@@ -276,6 +688,25 @@ public class BungeeHandler {
}
});
socketHandler.add(new SocketReceiver("VotePartyBungee") {
@Override
public void onReceive(String[] data) {
for (Player p : Bukkit.getOnlinePlayers()) {
new RewardBuilder(plugin.getBungeeSettings().getData(), "BungeeVotePartyRewards").send(p);
}
}
});
socketHandler.add(new SocketReceiver("VotePartyBroadcast") {
@Override
public void onReceive(String[] data) {
String broadcast = data[0];
MiscUtils.getInstance().broadcast(broadcast);
}
});
if (plugin.getOptions().getServer().equalsIgnoreCase("pleaseset")) {
plugin.getLogger().warning("Server name for bungee voting is not set, please set it");
}
@@ -1,9 +1,11 @@
package com.bencodez.votingplugin;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import org.bukkit.entity.Player;
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();
@@ -13,11 +15,17 @@ public class VotingPluginHooks {
}
public void addCustomRequirement(RequirementInject inject) {
RewardHandler.getInstance().addInjectedRequirements(inject);
getMainClass().getRewardHandler().addInjectedRequirements(inject);
}
public void addCustomReward(RewardInject inject) {
RewardHandler.getInstance().addInjectedReward(inject);
getMainClass().getRewardHandler().addInjectedReward(inject);
}
public void backgroundUpdate(Player player) {
VotingPluginUser user = getUserManager().getVotingPluginUser(player);
user.offVote();
user.checkOfflineRewards();
}
public VotingPluginMain getMainClass() {
File diff suppressed because it is too large. Load diff
@@ -1,54 +1,55 @@
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;
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() {
if (RewardHandler.getInstance().hasRewards(plugin.getSpecialRewardsConfig().getData(),
public String call() throws Exception {
if (plugin.getRewardHandler().hasRewards(plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getFirstVoteRewardsPath())) {
return "True";
} else {
return "False";
}
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_everysite") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_everysite", new Callable<String>() {
@Override
public String getValue() {
if (RewardHandler.getInstance().hasRewards(plugin.getConfigVoteSites().getData(),
public String call() throws Exception {
if (plugin.getRewardHandler().hasRewards(plugin.getConfigVoteSites().getData(),
plugin.getConfigVoteSites().getEverySiteRewardPath())) {
return "True";
} else {
return "False";
}
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_allsites") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("extrarewards_allsites", new Callable<String>() {
@Override
public String getValue() {
if (RewardHandler.getInstance().hasRewards(plugin.getSpecialRewardsConfig().getData(),
public String call() throws Exception {
if (plugin.getRewardHandler().hasRewards(plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getAllSitesRewardPath())) {
return "True";
} else {
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 +61,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,27 +88,27 @@ 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() {
if (RewardHandler.getInstance().hasRewards(plugin.getSpecialRewardsConfig().getData(),
public String call() throws Exception {
if (plugin.getRewardHandler().hasRewards(plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getAnySiteRewardsPath())) {
return "True";
} else {
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)
&& RewardHandler.getInstance().hasRewards(plugin.getSpecialRewardsConfig().getData(),
&& plugin.getRewardHandler().hasRewards(plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getVoteStreakRewardsPath("Day", s))) {
return "True";
}
@@ -115,16 +116,16 @@ 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)
&& RewardHandler.getInstance().hasRewards(plugin.getSpecialRewardsConfig().getData(),
&& plugin.getRewardHandler().hasRewards(plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getVoteStreakRewardsPath("Week", s))) {
return "True";
}
@@ -132,16 +133,16 @@ 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)
&& RewardHandler.getInstance().hasRewards(plugin.getSpecialRewardsConfig().getData(),
&& plugin.getRewardHandler().hasRewards(plugin.getSpecialRewardsConfig().getData(),
plugin.getSpecialRewardsConfig().getVoteStreakRewardsPath("Month", s))) {
return "True";
}
@@ -149,95 +150,215 @@ 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() {
return "" + RewardHandler.getInstance().getRewards().size();
public String call() throws Exception {
return "" + plugin.getRewardHandler().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";
if (total > 800000) {
return ">800000";
} else if (total > 700000) {
return "700000-800000";
} else if (total > 600000) {
return "600000-700000";
} else if (total > 500000) {
return "500000-600000";
} else if (total > 400000) {
return "400000-500000";
} else if (total > 300000) {
return "300000-400000";
} else if (total > 200000) {
return "200000-300000";
} else if (total > 100000) {
return "100000-200000";
} else if (total > 10000) {
return ">10000";
} else {
return "1000-10000";
return ">10000-100000";
}
return "<10000";
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("data_storage") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("data_storage", new Callable<String>() {
@Override
public String getValue() {
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("globaldata_enabled", new Callable<String>() {
@Override
public String call() throws Exception {
return "" + plugin.getBungeeSettings().isGloblalDataEnabled();
}
}));
if (plugin.getBungeeSettings().isGloblalDataEnabled()) {
metrics.addCustomChart(new BStatsMetrics.SimplePie("globaldata_usemainmysql", new Callable<String>() {
@Override
public String call() throws Exception {
return "" + plugin.getBungeeSettings().isGloblalDataUseMainMySQL();
}
}));
}
}
metrics.addCustomChart(new BStatsMetrics.SimplePie("persitecooldownevents", new Callable<String>() {
@Override
public String call() throws Exception {
return "" + plugin.getConfigFile().isPerSiteCoolDownEvents();
}
}));
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() && plugin.getRewardHandler()
.hasRewards(plugin.getSpecialRewardsConfig().getData(), "VoteCoolDownEndedReward"));
}
}));
if (!plugin.getBuildNumber().equals("NOTSET")) {
metrics.addCustomChart(new BStatsMetrics.SimplePie("dev_build_number", new Callable<String>() {
@Override
public String call() throws Exception {
return "" + plugin.getBuildNumber();
}
}));
}
}
}
@@ -2,9 +2,10 @@ 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 java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
@@ -15,32 +16,13 @@ import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.user.UserManager;
public class BroadcastHandler {
ConcurrentLinkedQueue<String> votedPlayers = new ConcurrentLinkedQueue<String>();
private Timer timer;
private VotingPluginMain plugin;
private ScheduledExecutorService timer;
ConcurrentLinkedQueue<String> votedPlayers = new ConcurrentLinkedQueue<String>();
public BroadcastHandler(VotingPluginMain plugin, int delay) {
this.plugin = plugin;
schelude(delay);
}
public void schelude(int delay) {
if (timer != null) {
timer.cancel();
} else {
timer = new Timer();
}
timer.schedule(new TimerTask() {
@Override
public void run() {
check();
}
}, 1000 * 60, 1000 * 60 * delay);
}
public void onVote(String player) {
votedPlayers.add(player);
schedule(delay);
}
public void check() {
@@ -51,8 +33,16 @@ public class BroadcastHandler {
}
String bc = StringParser.getInstance()
.colorize(plugin.getConfigFile().getFormatAlternateBroadcastBroadcast());
String playersText = "";
while (!votedPlayers.isEmpty()) {
playersText += votedPlayers.remove();
if (!votedPlayers.isEmpty()) {
playersText += ", ";
}
}
HashMap<String, String> placeholders = new HashMap<String, String>();
placeholders.put("numberofplayers", "" + size);
placeholders.put("players", playersText);
bc = StringParser.getInstance().replacePlaceHolder(bc, placeholders);
ArrayList<Player> players = new ArrayList<Player>();
for (Player p : Bukkit.getOnlinePlayers()) {
@@ -64,4 +54,24 @@ public class BroadcastHandler {
MiscUtils.getInstance().broadcast(bc, players);
}
}
public void onVote(String player) {
votedPlayers.add(player);
}
public void schedule(int delay) {
if (timer != null) {
timer.shutdownNow();
timer = Executors.newScheduledThreadPool(1);
} else {
timer = Executors.newScheduledThreadPool(1);
}
timer.scheduleWithFixedDelay(new Runnable() {
@Override
public void run() {
check();
}
}, 60, 60 * delay, TimeUnit.SECONDS);
}
}
File diff suppressed because it is too large. Load diff
@@ -7,20 +7,36 @@ import lombok.Getter;
public class BungeeMessageData {
// Message string
// alltimetotal//monthtotal//weeklytotal//dailytotal//points//milestonecount
// alltimetotal//monthtotal//weeklytotal//dailytotal//points//milestonecount//votepartycurrent//votepartyrequired
@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;
@Getter
private int votePartyCurrent = 0;
@Getter
private int votePartyRequired = 0;
public BungeeMessageData(int allTimeTotal, int monthTotal, int weeklyTotal, int dailyTotal, int points,
int milestoneCount, int votePartyCurrent, int votePartyRequired) {
this.allTimeTotal = allTimeTotal;
this.monthTotal = monthTotal;
this.weeklyTotal = weeklyTotal;
this.dailyTotal = dailyTotal;
this.points = points;
this.milestoneCount = milestoneCount;
this.votePartyCurrent = votePartyCurrent;
this.votePartyRequired = votePartyRequired;
}
public BungeeMessageData(String str) {
String[] data = str.split(Pattern.quote("//"));
@@ -32,22 +48,16 @@ public class BungeeMessageData {
points = Integer.parseInt(data[4]);
milestoneCount = Integer.parseInt(data[5]);
}
if (data.length >= 8) {
votePartyCurrent = Integer.parseInt(data[6]);
votePartyRequired = Integer.parseInt(data[7]);
}
}
@Override
public String toString() {
return allTimeTotal + "//" + monthTotal + "//" + weeklyTotal + "//" + dailyTotal + "//" + points + "//"
+ milestoneCount;
}
public BungeeMessageData(int allTimeTotal, int monthTotal, int weeklyTotal, int dailyTotal, int points,
int milestoneCount) {
this.allTimeTotal = allTimeTotal;
this.monthTotal = monthTotal;
this.weeklyTotal = weeklyTotal;
this.dailyTotal = dailyTotal;
this.points = points;
this.milestoneCount = milestoneCount;
+ milestoneCount + "//" + votePartyCurrent + "//" + votePartyRequired;
}
}
@@ -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);
}
}
}
@@ -21,30 +21,50 @@ public class Config {
this.bungee = bungee;
}
public boolean getAllowUnJoined() {
return getData().getBoolean("AllowUnJoined", false);
}
public List<String> getBlockedServers() {
return getData().getStringList("BlockedServers");
}
public List<String> getWhiteListedServers() {
return getData().getStringList("WhiteListedServers");
}
public boolean getBroadcast() {
return getData().getBoolean("Broadcast", false);
}
public boolean getWaitForUserOnline() {
return getData().getBoolean("WaitForUserOnline", false);
public boolean getGeyserSupport() {
return getData().getBoolean("GeyserSupport", false);
}
public boolean getBungeeManageTotals() {
return getData().getBoolean("BungeeManageTotals", true);
public String getGeyserPrefix() {
return getData().getString("GeyserPrefix", ".");
}
public boolean getAllowUnJoined() {
return getData().getBoolean("AllowUnJoined", false);
public boolean getOnlineMode() {
return getData().getBoolean("OnlineMode", true);
}
public boolean getGlobalDataEnabled() {
return getData().getBoolean("GlobalData.Enabled", false);
}
public boolean getGlobalDataUseMainMySQL() {
return getData().getBoolean("GlobalData.UseMainMySQL", true);
}
public String getBungeeHost() {
return getData().getString("BungeeServer.Host", "");
}
public boolean getBungeeManageTotals() {
return getData().getBoolean("BungeeManageTotals", true);
}
public String getBungeeMethod() {
return getData().getString("BungeeMethod", "SOCKETS");
}
@@ -57,10 +77,42 @@ public class Config {
return getData().getBoolean("Debug", false);
}
public boolean getMultiProxySupport() {
return getData().getBoolean("MultiProxySupport", false);
}
public int getMultiProxySocketHostPort() {
return getData().getInt("MultiProxySocketHost.Port", 1297);
}
public String getMultiProxySocketHostHost() {
return getData().getString("MultiProxySocketHost.Host", "");
}
public boolean getMultiProxyOneGlobalReward() {
return getData().getBoolean("MultiProxyOneGlobalReward", false);
}
public Configuration getMultiProxyServersConfiguration(String s) {
return getData().getSection("MultiProxyServers." + s);
}
public Collection<String> getMultiProxyServers() {
return getData().getSection("MultiProxyServers").getKeys();
}
public boolean getPrimaryServer() {
return getData().getBoolean("PrimaryServer", false);
}
public String getFallBack() {
return getData().getString("FallBackServer", "");
}
public int getPointsOnVote() {
return getData().getInt("PointsOnVote", 1);
}
public boolean getSendVotesToAllServers() {
return getData().getBoolean("SendVotesToAllServers");
}
@@ -73,6 +125,38 @@ public class Config {
return getData().getSection("SpigotServers").getKeys();
}
public boolean getWaitForUserOnline() {
return getData().getBoolean("WaitForUserOnline", false);
}
public boolean getVotePartyEnabled() {
return getData().getBoolean("VoteParty.Enabled", false);
}
public boolean getVotePartySendToAllServers() {
return getData().getBoolean("VoteParty.SendToAllServers", true);
}
public int getVotePartyVotesRequired() {
return getData().getInt("VoteParty.VotesRequired", 100);
}
public int getVotePartyIncreaseVotesRequired() {
return getData().getInt("VoteParty.IncreaseVotesRequired", 0);
}
public String getVotePartyBroadcast() {
return getData().getString("VoteParty.Broadcast", "");
}
public List<String> getVotePartyServersToSend() {
return getData().getStringList("VoteParty.ServersToSend");
}
public List<String> getVotePartyBungeeCommands() {
return getData().getStringList("VoteParty.BungeeCommands");
}
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,
@@ -4,6 +4,8 @@ import java.io.File;
import java.io.IOException;
import java.util.Collection;
import com.bencodez.votingplugin.timequeue.VoteTimeQueue;
import lombok.Getter;
import net.md_5.bungee.config.Configuration;
import net.md_5.bungee.config.ConfigurationProvider;
@@ -18,6 +20,30 @@ public class VoteCache {
this.bungee = bungee;
}
public int getVotePartyCurrentVotes() {
return getData().getInt("VoteParty.CurrentVotes", 0);
}
public int getVotePartyInreaseVotesRequired() {
return getData().getInt("VoteParty.IncreaseVotes", 0);
}
public void setVotePartyCurrentVotes(int amount) {
getData().set("VoteParty.CurrentVotes", amount);
}
public void setVotePartyInreaseVotesRequired(int amount) {
getData().set("VoteParty.IncreaseVotes", amount);
}
public void setVotePartyCache(String server, int amount) {
getData().set("VoteParty.Cache." + server, amount);
}
public int getVotePartyCache(String server) {
return getData().getInt("VoteParty.Cache." + server, 0);
}
public void addVote(String server, int num, OfflineBungeeVote voteData) {
Configuration section = getData().getSection("VoteCache." + server + "." + num);
section.set("Name", voteData.getPlayerName());
@@ -26,7 +52,13 @@ public class VoteCache {
section.set("Time", voteData.getTime());
section.set("Real", voteData.isRealVote());
section.set("Text", voteData.getText());
save();
}
public void addTimedVote(int num, VoteTimeQueue voteTimedQueue) {
Configuration section = getData().getSection("TimedVoteCache." + num);
section.set("Name", voteTimedQueue.getName());
section.set("Service", voteTimedQueue.getService());
section.set("Time", voteTimedQueue.getTime());
}
public void addVoteOnline(String player, int num, OfflineBungeeVote voteData) {
@@ -37,7 +69,6 @@ public class VoteCache {
section.set("Time", voteData.getTime());
section.set("Real", voteData.isRealVote());
section.set("Text", voteData.getText());
save();
}
public void clearData() {
@@ -62,6 +93,14 @@ public class VoteCache {
return getData().getSection("VoteCache").getKeys();
}
public Configuration getTimedVoteCache(String key) {
return getData().getSection("TimedVoteCache." + key);
}
public Collection<String> getTimedVoteCache() {
return getData().getSection("TimedVoteCache").getKeys();
}
public Collection<String> getServerVotes(String server) {
return getData().getSection("VoteCache." + server).getKeys();
}
@@ -14,10 +14,24 @@ public class VoteEventBungee implements net.md_5.bungee.api.plugin.Listener {
@EventHandler
public void onVote(VotifierEvent event) {
Vote vote = event.getVote();
plugin.getLogger().info("Vote received " + vote.getUsername() + " from service site " + vote.getServiceName());
plugin.getProxy().getScheduler().runAsync(plugin, new Runnable() {
plugin.vote(vote.getUsername(), vote.getServiceName(), true);
@SuppressWarnings("deprecation")
@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";
vote.setServiceName(serviceSite);
}
plugin.vote(vote.getUsername(), serviceSite, true, true, 0, null, null);
}
});
}
}
File diff suppressed because it is too large. Load diff
@@ -1,5 +1,7 @@
package com.bencodez.votingplugin.bungee;
import com.bencodez.advancedcore.api.time.TimeType;
import net.md_5.bungee.api.CommandSender;
import net.md_5.bungee.api.chat.TextComponent;
import net.md_5.bungee.api.plugin.Command;
@@ -17,40 +19,91 @@ public class VotingPluginBungeeCommand extends Command {
if (sender.hasPermission("votingplugin.admin")) {
if (args.length > 0) {
if (args[0].equalsIgnoreCase("reload")) {
bungee.reload();
bungee.reload(false);
sender.sendMessage(new TextComponent("Reloading VotingPluginBungee"));
}
if (args[0].equalsIgnoreCase("reloadmysql")) {
bungee.reload(true);
sender.sendMessage(new TextComponent("Reloading VotingPluginBungee with MySQL"));
}
if (args[0].equalsIgnoreCase("vote")) {
if (args.length >= 2) {
String user = args[1];
String site = args[2];
bungee.vote(user, site, false);
bungee.vote(user, site, false, true, 0, null, null);
sender.sendMessage(new TextComponent("Sending vote"));
}
}
if (args[0].equalsIgnoreCase("forcetimechange")) {
if (args.length >= 2) {
bungee.getBungeeTimeChecker().forceChanged(TimeType.getTimeType(args[1]));
sender.sendMessage(new TextComponent("Triggering time change: " + args[1]));
}
}
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("multiproxystatus")) {
bungee.sendMultiProxyServerMessage("Status");
sender.sendMessage(new TextComponent("&aSending status message"));
}
if (args[0].equalsIgnoreCase("help")) {
TextComponent[] msg = new TextComponent[3];
TextComponent[] msg = new TextComponent[7];
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");
msg[4] = new TextComponent("&avotingpluginbungee forcetimechange (timetype) - Force a time change");
msg[5] = new TextComponent("&avotingpluginbungee voteparty force - Force a vote party");
msg[6] = new TextComponent(
"&avotingpluginbungee voteparty setvotecount (number) - Set current vote party votes");
sender.sendMessage(msg);
}
if (args[0].equalsIgnoreCase("voteparty")) {
if (args.length > 1) {
if (args[1].equalsIgnoreCase("Force")) {
bungee.setCurrentVotePartyVotes(bungee.getCurrentVotePartyVotesRequired());
bungee.checkVoteParty();
sender.sendMessage(new TextComponent("Vote party forced"));
}
if (args.length > 2) {
if (args[1].equalsIgnoreCase("SetVoteCount")) {
if (isInt(args[2])) {
bungee.setCurrentVotePartyVotes(Integer.parseInt(args[2]));
sender.sendMessage(new TextComponent("Set current vote party votes to " + args[2]));
}
}
}
}
}
}
} 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!"));
}
}
public boolean isInt(String st) {
if (st == null) {
return false;
}
try {
@SuppressWarnings("unused")
int num = Integer.parseInt(st);
return true;
} catch (NumberFormatException ex) {
return false;
}
}
}
@@ -0,0 +1,164 @@
package com.bencodez.votingplugin.bungee.velocity;
import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.checkerframework.checker.nullness.qual.NonNull;
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 List<String> getWhiteListedServers() {
return getStringList(getNode("WhiteListedServers"), new ArrayList<String>());
}
public boolean getBroadcast() {
return getBoolean(getNode("Broadcast"), false);
}
public boolean getOnlineMode() {
return getBoolean(getNode("OnlineMode"), true);
}
public boolean getGlobalDataEnabled() {
return getBoolean(getNode("GlobalData", "Enabled"), false);
}
public boolean getGlobalDataUseMainMySQL() {
return getBoolean(getNode("GlobalData", "UseMainMySQL"), true);
}
public boolean getBungeeManageTotals() {
return getBoolean(getNode("BungeeManageTotals"), true);
}
public String getBungeeMethod() {
return getString(getNode("BungeeMethod"), "PLUGINMESSAGING");
}
public String getBungeeHost() {
return getString(getNode("BungeeServer", "Host"), "");
}
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 boolean getVotePartyEnabled() {
return getBoolean(getVotePartyNode().getNode("Enabled"), false);
}
public ConfigurationNode getVotePartyNode() {
return getNode("VoteParty");
}
public boolean getVotePartySendToAllServers() {
return getBoolean(getVotePartyNode().getNode("SendToAllServers"), false);
}
public int getVotePartyVotesRequired() {
return getInt(getVotePartyNode().getNode("VotesRequired"), 100);
}
public int getVotePartyIncreaseVotesRequired() {
return getInt(getVotePartyNode().getNode("IncreaseVotesRequired"), 0);
}
public String getVotePartyBroadcast() {
return getString(getVotePartyNode().getNode("Broadcast"), "");
}
public List<String> getVotePartyServersToSend() {
return getStringList(getVotePartyNode().getNode("ServersToSend"), new ArrayList<String>());
}
public List<String> getVotePartyBungeeCommands() {
return getStringList(getVotePartyNode().getNode("BungeeCommands"), new ArrayList<String>());
}
public ConfigurationNode getSpigotServerConfiguration(String s) {
return getNode("SpigotServers", s);
}
public @NonNull Collection<? extends ConfigurationNode> getSpigotServers() {
return getNode("SpigotServers").getChildrenMap().values();
}
public boolean getWaitForUserOnline() {
return getBoolean(getNode("WaitForUserOnline"), false);
}
public boolean getMultiProxySupport() {
return getBoolean(getNode("MultiProxySupport"), false);
}
public boolean getMultiProxyOneGlobalReward() {
return getBoolean(getNode("MultiProxyOneGlobalReward"), false);
}
public boolean getGeyserSupport() {
return getBoolean(getNode("GeyserSupport"), false);
}
public boolean getPrimaryServer() {
return getBoolean(getNode("PrimaryServer"), false);
}
public String getGeyserPrefix() {
return getString(getNode("GeyserPrefix"), "*");
}
public ConfigurationNode getMultiProxyServers(String s) {
return getNode("MultiProxyServers", s);
}
public @NonNull Collection<? extends ConfigurationNode> getMultiProxyServers() {
return getNode("MultiProxyServers").getChildrenMap().values();
}
public String getMultiProxySocketHostHost() {
return getString(getNode("MultiProxySocketHost", "Host"), "");
}
public int getMultiProxySocketHostPort() {
return getInt(getNode("MultiProxySocketHost", "Port"), 1297);
}
}
@@ -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,109 @@
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 com.bencodez.votingplugin.timequeue.VoteTimeQueue;
import ninja.leaping.configurate.ConfigurationNode;
public class VoteCache extends VelocityYMLFile {
public VoteCache(File file) {
super(file);
}
public int getVotePartyCurrentVotes() {
return getInt(getNode("VoteParty").getNode("CurrentVotes"), 0);
}
public int getVotePartyInreaseVotesRequired() {
return getInt(getNode("VoteParty").getNode("IncreaseVotes"), 0);
}
public void setVotePartyCurrentVotes(int amount) {
getNode("VoteParty").getNode("CurrentVotes").setValue(amount);
}
public void setVotePartyInreaseVotesRequired(int amount) {
getNode("VoteParty").getNode("IncreaseVotes").setValue(amount);
}
public void setVotePartyCache(String server, int amount) {
getNode("VoteParty").getNode("Cache").getNode(server).setValue(amount);
}
public int getVotePartyCache(String server) {
return getNode("VoteParty").getNode("Cache").getNode(server).getInt(0);
}
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 addTimedVote(int num, VoteTimeQueue voteTimedQueue) {
String[] path = new String[] { "TimedVoteCache", "" + num };
getNode(path, "Name").setValue(voteTimedQueue.getName());
getNode(path, "Service").setValue(voteTimedQueue.getService());
getNode(path, "Time").setValue(voteTimedQueue.getTime());
}
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 getTimedVoteCache(String name) {
return getNode("TimedVoteCache", 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> getTimedVoteCache() {
return getKeys(getNode("TimedVoteCache"));
}
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,32 @@
package com.bencodez.votingplugin.bungee.velocity;
import com.velocitypowered.api.event.Subscribe;
import com.vexsoftware.votifier.velocity.event.VotifierEvent;
public class VoteEventVelocity {
private VotingPluginVelocity plugin;
public VoteEventVelocity(VotingPluginVelocity plugin) {
this.plugin = plugin;
}
@Subscribe
public void onVotifierEvent(VotifierEvent event) {
final String serviceSiteVote = event.getVote().getServiceName();
final String name = event.getVote().getUsername();
plugin.getTimer().execute(new Runnable() {
@Override
public void run() {
String serviceSite = serviceSiteVote;
plugin.getLogger().info("Vote received " + name + " from service site " + serviceSite);
if (serviceSite.isEmpty()) {
serviceSite = "Empty";
}
plugin.vote(name, serviceSite, true, false, 0, null, null);
}
});
}
}
@@ -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,119 @@
package com.bencodez.votingplugin.bungee.velocity;
import com.bencodez.advancedcore.api.time.TimeType;
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, true, 0, null, null);
source.sendMessage(Component.text("Sending vote").color(NamedTextColor.AQUA));
}
}
if (args[0].equalsIgnoreCase("forcetimechange")) {
if (args.length >= 2) {
plugin.getBungeeTimeChecker().forceChanged(TimeType.getTimeType(args[1]));
source.sendMessage(Component.text("Triggering time change: " + args[1]).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("multiproxystatus")) {
plugin.sendMultiProxyServerMessage("Status");
source.sendMessage(Component.text("Sending status message").color(NamedTextColor.AQUA));
}
if (args[0].equalsIgnoreCase("help")) {
String[] msg = new String[7];
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";
msg[4] = "&avotingpluginbungee forcetimechange (timetype) - Force a time change";
msg[5] = "&avotingpluginbungee voteparty force - Force a vote party";
msg[6] = "&avotingpluginbungee voteparty setvotecount (number) - Set current vote party votes";
for (String m : msg) {
source.sendMessage(Component.text(m).color(NamedTextColor.AQUA));
}
}
if (args[0].equalsIgnoreCase("voteparty")) {
if (args.length > 1) {
if (args[1].equalsIgnoreCase("Force")) {
plugin.setCurrentVotePartyVotes(plugin.getCurrentVotePartyVotesRequired());
plugin.checkVoteParty();
source.sendMessage(Component.text("Vote party forced").color(NamedTextColor.AQUA));
}
if (args.length > 2) {
if (args[1].equalsIgnoreCase("SetVoteCount")) {
if (isInt(args[2])) {
plugin.setCurrentVotePartyVotes(Integer.parseInt(args[2]));
source.sendMessage(Component.text("Set current vote party votes to " + args[2])
.color(NamedTextColor.AQUA));
}
}
}
}
}
}
}
public boolean isInt(String st) {
if (st == null) {
return false;
}
try {
@SuppressWarnings("unused")
int num = Integer.parseInt(st);
return true;
} catch (NumberFormatException ex) {
return false;
}
}
@Override
public boolean hasPermission(final Invocation invocation) {
return invocation.source().hasPermission("votingpluginbungee.admin");
}
}
File diff suppressed because it is too large. Load diff
@@ -21,13 +21,13 @@ import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueSt
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;
@@ -65,6 +65,7 @@ public class AdminGUI {
plugin.getConfigVoteSites().generateVoteSite(value);
player.sendMessage("Generated site");
plugin.reload();
openAdminGUIVoteSiteSite(player, plugin.getVoteSite(value, true));
}
});
} else {
@@ -109,7 +110,15 @@ public class AdminGUI {
@Override
public void onClick(ClickEvent clickEvent) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(),
RewardHandler.getInstance().getDirectlyDefined("FirstVote"));
plugin.getRewardHandler().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(),
plugin.getRewardHandler().getDirectlyDefined("FirstVoteToday"));
}
});
@@ -118,25 +127,51 @@ public class AdminGUI {
@Override
public void onClick(ClickEvent clickEvent) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(),
RewardHandler.getInstance().getDirectlyDefined("AllSites"));
plugin.getRewardHandler().getDirectlyDefined("AllSites"));
}
});
buttons.add(new BInventoryButton(new ItemBuilder(Material.STONE, 1).setName("&cEdit AlmostAllSites reward")) {
@Override
public void onClick(ClickEvent clickEvent) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(),
plugin.getRewardHandler().getDirectlyDefined("AlmostAllSites"));
}
});
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"));
plugin.getRewardHandler().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"));
plugin.getRewardHandler().getDirectlyDefined("EverySiteReward"));
}
});
buttons.add(new BInventoryButton(new ItemBuilder(Material.STONE, 1).setName("&cEdit BungeeVotePartyRewards")) {
@Override
public void onClick(ClickEvent clickEvent) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(),
plugin.getRewardHandler().getDirectlyDefined("BungeeVotePartyRewards"));
}
});
buttons.add(new BInventoryButton(new ItemBuilder("GRASS_BLOCK").setName("&cEdit BungeeSettings.yml")) {
@Override
public void onClick(ClickEvent clickEvent) {
new AdminVoteBungeeSettings(plugin, clickEvent.getPlayer()).open();
}
});
@@ -216,7 +251,13 @@ public class AdminGUI {
if (ob != null) {
VoteSite site = (VoteSite) ob;
PlayerVoteEvent voteEvent = new PlayerVoteEvent(site, value, site.getServiceSite(), false);
plugin.getServer().getPluginManager().callEvent(voteEvent);
plugin.getVoteTimer().submit(new Runnable() {
@Override
public void run() {
plugin.getServer().getPluginManager().callEvent(voteEvent);
}
});
}
}
}, ArrayUtils.getInstance().convert(playerNames)).usingMethod(InputMethod.INVENTORY)
@@ -276,7 +317,7 @@ public class AdminGUI {
plugin.reload();
}
}));
inv.addButton(new EditGUIButton(new EditGUIValueNumber("VoteDelayMin", voteSite.getVoteDelay()) {
@Override
@@ -338,12 +379,35 @@ public class AdminGUI {
@Override
public void onClick(ClickEvent clickEvent) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(), RewardHandler.getInstance()
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(), plugin.getRewardHandler()
.getDirectlyDefined("VoteSites." + voteSite.getKey() + ".Rewards"));
}
});
}
if (voteSite.getSiteData().isList("CoolDownEndRewards")) {
inv.addButton(new EditGUIButton(new EditGUIValueList("CoolDownEndRewards",
voteSite.getSiteData().getStringList("CoolDownEndRewards")) {
@Override
public void setValue(Player p, ArrayList<String> rewards) {
VoteSite voteSite = (VoteSite) getInv().getMeta(player, "VoteSite");
plugin.getConfigVoteSites().set(voteSite.getKey(), "CoolDownEndRewards", rewards);
plugin.reload();
}
}));
} else {
inv.addButton(new BInventoryButton(new ItemBuilder(Material.DISPENSER, 1).setName("&cCoolDownEndRewards")) {
@Override
public void onClick(ClickEvent clickEvent) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(), plugin.getRewardHandler()
.getDirectlyDefined("VoteSites." + voteSite.getKey() + ".CoolDownEndRewards"));
}
});
}
inv.openInventory(player);
}
}
@@ -0,0 +1,147 @@
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("PerServerMilestones", plugin.getBungeeSettings().isPerServerMilestones()) {
@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();
}
}
@@ -21,7 +21,7 @@ public abstract class AdminVoteConfirmation extends GUIHandler {
private String title;
public AdminVoteConfirmation(VotingPluginMain plugin, CommandSender player, String title) {
super(player);
super(plugin, player);
this.plugin = plugin;
this.title = title;
}
@@ -40,10 +40,6 @@ public abstract class AdminVoteConfirmation extends GUIHandler {
}
public abstract void onConfirm(Player p);
public abstract void onDeny(Player p);
@Override
public void onChest(Player player) {
BInventory inv = new BInventory(title);
@@ -64,6 +60,10 @@ public abstract class AdminVoteConfirmation extends GUIHandler {
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;
}
@@ -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;
@@ -11,6 +11,7 @@ import com.bencodez.advancedcore.api.bookgui.BookWrapper;
import com.bencodez.advancedcore.api.bookgui.Layout;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.placeholder.NonPlayerPlaceHolder;
import com.bencodez.advancedcore.api.placeholder.PlaceHolder;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.user.VotingPluginUser;
@@ -19,11 +20,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;
}
@@ -54,7 +54,7 @@ public class AdminVotePlaceholders extends GUIHandler {
book.addLayout(layout);
}
for (PlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getNonPlayerPlaceholders()) {
for (NonPlayerPlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getNonPlayerPlaceholders()) {
String msg = "";
String identifier = placeholder.getIdentifier();
if (identifier.endsWith("_")) {
@@ -93,7 +93,7 @@ public class AdminVotePlaceholders extends GUIHandler {
}
}
for (PlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getNonPlayerPlaceholders()) {
for (NonPlayerPlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getNonPlayerPlaceholders()) {
String identifier = placeholder.getIdentifier();
if (identifier.endsWith("_")) {
identifier += "#";
@@ -11,6 +11,7 @@ import com.bencodez.advancedcore.api.bookgui.BookWrapper;
import com.bencodez.advancedcore.api.bookgui.Layout;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.placeholder.NonPlayerPlaceHolder;
import com.bencodez.advancedcore.api.placeholder.PlaceHolder;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.user.UserManager;
@@ -20,12 +21,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;
}
@@ -44,7 +44,7 @@ public class AdminVotePlaceholdersPlayer extends GUIHandler {
if (identifier.endsWith("_")) {
identifier += "1";
}
String value = placeholder.placeholderRequest(user.getOfflinePlayer(), user, identifier);
String value = placeholder.placeholderRequest(user, identifier);
String msg = identifier + " = " + value;
Layout layout = new Layout(new ArrayList<String>(Arrays.asList("[Json]")));
layout.replaceTextComponent("[Json]", BookUtil.TextBuilder.of(msg).color(ChatColor.AQUA)
@@ -52,13 +52,13 @@ public class AdminVotePlaceholdersPlayer extends GUIHandler {
book.addLayout(layout);
}
for (PlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getNonPlayerPlaceholders()) {
for (NonPlayerPlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getNonPlayerPlaceholders()) {
String identifier = placeholder.getIdentifier();
if (identifier.endsWith("_")) {
identifier += "1";
}
String value = placeholder.placeholderRequest(user.getOfflinePlayer(), user, identifier);
String value = placeholder.placeholderRequest(identifier);
String msg = identifier + " = " + value;
Layout layout = new Layout(new ArrayList<String>(Arrays.asList("[Json]")));
@@ -82,18 +82,16 @@ public class AdminVotePlaceholdersPlayer extends GUIHandler {
if (identifier.endsWith("_")) {
identifier += "1";
}
msg.add("VotingPlugin_" + identifier + " = "
+ placeholder.placeholderRequest(user.getOfflinePlayer(), placeholderUser, identifier));
msg.add("VotingPlugin_" + identifier + " = " + placeholder.placeholderRequest(placeholderUser, identifier));
}
for (PlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getNonPlayerPlaceholders()) {
for (NonPlayerPlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getNonPlayerPlaceholders()) {
String identifier = placeholder.getIdentifier();
if (identifier.endsWith("_")) {
identifier += "1";
}
msg.add("VotingPlugin_" + identifier + " = "
+ placeholder.placeholderRequest(user.getOfflinePlayer(), placeholderUser, identifier));
msg.add("VotingPlugin_" + identifier + " = " + placeholder.placeholderRequest(identifier));
}
sendMessage(msg);
}
@@ -17,7 +17,6 @@ import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueLi
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;
@@ -28,7 +27,7 @@ public class AdminVoteVoteParty extends GUIHandler {
private VotingPluginMain plugin;
public AdminVoteVoteParty(VotingPluginMain plugin, CommandSender player) {
super(player);
super(plugin, player);
this.plugin = plugin;
}
@@ -46,12 +45,6 @@ public class AdminVoteVoteParty extends GUIHandler {
}
private void setPathData(String path, Object value) {
plugin.getSpecialRewardsConfig().getData().set("VoteParty." + path, value);
plugin.getSpecialRewardsConfig().saveData();
plugin.reload();
}
@Override
public void onChest(Player player) {
EditGUI inv = new EditGUI("Edit VoteParty");
@@ -99,7 +92,7 @@ public class AdminVoteVoteParty extends GUIHandler {
}, new Number[] { 0, 10, 50, 100 })
.currentValue("" + plugin.getServerData().getVotePartyExtraRequired()).allowCustomOption(true)
.request(clickEvent.getPlayer());
;
}
});
@@ -121,6 +114,15 @@ public class AdminVoteVoteParty extends GUIHandler {
}
}));
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()) {
@@ -194,7 +196,7 @@ public class AdminVoteVoteParty extends GUIHandler {
}));
inv.addButton(new EditGUIButton(new ItemBuilder(Material.PAPER, 1),
new EditGUIValueList("Commands", plugin.getSpecialRewardsConfig().getVotePartyCommands()) {
new EditGUIValueList("Commands", plugin.getSpecialRewardsConfig().getVotePartyGlobalCommands()) {
@Override
public void setValue(Player player, ArrayList<String> value) {
@@ -209,7 +211,7 @@ public class AdminVoteVoteParty extends GUIHandler {
@Override
public void onClick(ClickEvent clickEvent) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(),
RewardHandler.getInstance().getDirectlyDefined("VoteParty.Rewards"));
plugin.getRewardHandler().getDirectlyDefined("VoteParty.Rewards"));
}
});
@@ -223,4 +225,10 @@ public class AdminVoteVoteParty extends GUIHandler {
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);
}
}
@@ -13,7 +13,6 @@ 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;
@@ -26,7 +25,7 @@ public class AdminVoteCumulative extends GUIHandler {
private VotingPluginMain plugin;
public AdminVoteCumulative(VotingPluginMain plugin, CommandSender player) {
super(player);
super(plugin, player);
this.plugin = plugin;
}
@@ -48,30 +47,34 @@ public class AdminVoteCumulative extends GUIHandler {
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() {
inv.addButton(
new BInventoryButton(new ItemBuilder(Material.PAPER).setName("&cEdit existing cumulative rewards")) {
@Override
public void onInput(Player player, Number value) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(),
RewardHandler.getInstance().getDirectlyDefined("Cumulative." + value.intValue() + ".Rewards"));
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(),
plugin.getRewardHandler()
.getDirectlyDefined("Cumulative." + value.intValue() + ".Rewards"));
}
}, options).allowCustomOption(false).usingMethod(InputMethod.INVENTORY)
.request(clickEvent.getPlayer());
}
}, options).allowCustomOption(false).usingMethod(InputMethod.INVENTORY).request(clickEvent.getPlayer());;
}
});
});
inv.addButton(new BInventoryButton(new ItemBuilder(Material.EMERALD_BLOCK).setName("&aAdd cumulative reward")) {
@@ -20,7 +20,7 @@ public class AdminVoteCumulativeRemove extends GUIHandler {
private VotingPluginMain plugin;
public AdminVoteCumulativeRemove(VotingPluginMain plugin, CommandSender player) {
super(player);
super(plugin, player);
this.plugin = plugin;
}
@@ -50,18 +50,19 @@ public class AdminVoteCumulativeRemove extends GUIHandler {
public void onClick(ClickEvent clickEvent) {
new AdminVoteConfirmation(plugin, clickEvent.getPlayer(), "Remove cumulative " + votes + "?") {
@Override
public void onDeny(Player p) {
new AdminVoteCumulative(plugin, p);
}
@Override
public void onConfirm(Player p) {
plugin.getSpecialRewardsConfig().removeCumulative(votes);
p.sendMessage("Removed cumulative " + votes);
plugin.reload();
}
}.open();;
@Override
public void onDeny(Player p) {
new AdminVoteCumulative(plugin, p);
}
}.open();
}
});
@@ -20,7 +20,7 @@ public class AdminVoteMilestoneRemove extends GUIHandler {
private VotingPluginMain plugin;
public AdminVoteMilestoneRemove(VotingPluginMain plugin, CommandSender player) {
super(player);
super(plugin, player);
this.plugin = plugin;
}
@@ -50,18 +50,19 @@ public class AdminVoteMilestoneRemove extends GUIHandler {
public void onClick(ClickEvent clickEvent) {
new AdminVoteConfirmation(plugin, clickEvent.getPlayer(), "Remove milestone " + votes + "?") {
@Override
public void onDeny(Player p) {
new AdminVoteMilestones(plugin, p);
}
@Override
public void onConfirm(Player p) {
plugin.getSpecialRewardsConfig().removeMilestone(votes);
p.sendMessage("Removed milestone " + votes);
plugin.reload();
}
}.open();;
@Override
public void onDeny(Player p) {
new AdminVoteMilestones(plugin, p);
}
}.open();
}
});
@@ -13,7 +13,6 @@ 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;
@@ -26,7 +25,7 @@ public class AdminVoteMilestones extends GUIHandler {
private VotingPluginMain plugin;
public AdminVoteMilestones(VotingPluginMain plugin, CommandSender player) {
super(player);
super(plugin, player);
this.plugin = plugin;
}
@@ -68,10 +67,12 @@ public class AdminVoteMilestones extends GUIHandler {
@Override
public void onInput(Player player, Number value) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(),
RewardHandler.getInstance()
plugin.getRewardHandler()
.getDirectlyDefined("MileStones." + value.intValue() + ".Rewards"));
}
}, options).allowCustomOption(false).usingMethod(InputMethod.INVENTORY).request(clickEvent.getPlayer());;
}, options).allowCustomOption(false).usingMethod(InputMethod.INVENTORY)
.request(clickEvent.getPlayer());
}
});
@@ -21,7 +21,7 @@ public class AdminVoteVoteShop extends GUIHandler {
private VotingPluginMain plugin;
public AdminVoteVoteShop(VotingPluginMain plugin, CommandSender player) {
super(player);
super(plugin, player);
this.plugin = plugin;
}
@@ -9,25 +9,24 @@ import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.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 VotingPluginMain plugin;
private String identifier;
private VotingPluginMain plugin;
public AdminVoteVoteShopItem(VotingPluginMain plugin, CommandSender player, String identifier) {
super(player);
super(plugin, player);
this.plugin = plugin;
this.identifier = identifier;
}
@@ -46,12 +45,6 @@ public class AdminVoteVoteShopItem extends GUIHandler {
}
private void setPathData(String path, Object value) {
plugin.getGui().getData().set("CHEST.Shop." + identifier + "." + path, value);
plugin.getGui().saveData();
plugin.reload();
}
@Override
public void onChest(Player player) {
EditGUI inv = new EditGUI("Edit VoteShop Item: " + identifier);
@@ -92,7 +85,7 @@ public class AdminVoteVoteShopItem extends GUIHandler {
// display item
ConfigurationSection displayItemData = plugin.getGui().getChestShopIdentifierSection(identifier);
inv.addButton(new EditGUIButton(new ItemBuilder(Material.valueOf(displayItemData.getString("Material")), 1),
inv.addButton(new EditGUIButton(new ItemBuilder(displayItemData.getString("Material")).setAmount(1),
new EditGUIValueString("Material", displayItemData.getString("Material")) {
@Override
@@ -121,7 +114,7 @@ public class AdminVoteVoteShopItem extends GUIHandler {
@Override
public void onClick(ClickEvent clickEvent) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(),
RewardHandler.getInstance().getDirectlyDefined("CHEST.Shop." + identifier + ".Rewards"));
plugin.getRewardHandler().getDirectlyDefined("CHEST.Shop." + identifier + ".Rewards"));
}
});
@@ -135,4 +128,10 @@ public class AdminVoteVoteShopItem extends GUIHandler {
open(GUIMethod.CHEST);
}
private void setPathData(String path, Object value) {
plugin.getGui().getData().set("CHEST.Shop." + identifier + "." + path, value);
plugin.getGui().saveData();
plugin.reload();
}
}
@@ -19,7 +19,7 @@ public class AdminVoteVoteShopItemRemove extends GUIHandler {
private VotingPluginMain plugin;
public AdminVoteVoteShopItemRemove(VotingPluginMain plugin, CommandSender player) {
super(player);
super(plugin, player);
this.plugin = plugin;
}
@@ -41,7 +41,7 @@ public class AdminVoteVoteShopItemRemove extends GUIHandler {
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))
@@ -52,18 +52,19 @@ public class AdminVoteVoteShopItemRemove extends GUIHandler {
new AdminVoteConfirmation(plugin, clickEvent.getPlayer(),
"Remove shop item " + identifier + "?") {
@Override
public void onDeny(Player p) {
new AdminVoteVoteShop(plugin, p).open();
}
@Override
public void onConfirm(Player p) {
plugin.getGui().removeShop(identifier);
p.sendMessage("Removed " + identifier);
plugin.reload();
}
}.open();;
@Override
public void onDeny(Player p) {
new AdminVoteVoteShop(plugin, p).open();
}
}.open();
}
}.addData("ident", identifier));
@@ -18,7 +18,7 @@ public class AdminVoteVoteShopItems extends GUIHandler {
private VotingPluginMain plugin;
public AdminVoteVoteShopItems(VotingPluginMain plugin, CommandSender player) {
super(player);
super(plugin, player);
this.plugin = plugin;
}
@@ -40,7 +40,7 @@ public class AdminVoteVoteShopItems extends GUIHandler {
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))) {
@@ -49,7 +49,7 @@ public class AdminVoteVoteShopItems extends GUIHandler {
public void onClick(ClickEvent clickEvent) {
new AdminVoteVoteShopItem(plugin, clickEvent.getPlayer(), (String) getData("ident"))
.open(GUIMethod.CHEST);
;
}
}.addData("ident", identifier));
}
@@ -13,17 +13,17 @@ import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.misc.ArrayUtils;
import com.bencodez.advancedcore.api.rewards.RewardBuilder;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.user.VotingPluginUser;
public class VoteBest extends GUIHandler {
@SuppressWarnings("unused")
private VotingPluginMain plugin;
private VotingPluginUser user;
public VoteBest(VotingPluginMain plugin, CommandSender player, VotingPluginUser user) {
super(player);
super(plugin, player);
this.plugin = plugin;
this.user = user;
}
@@ -88,6 +88,25 @@ public class VoteBest extends GUIHandler {
}
});
if (plugin.getGui().isChestVoteBestBackButton()) {
inv.addButton(plugin.getCommandLoader().getBackButton(user));
}
String guiPath = "VoteBest";
for (final String str : plugin.getGui().getChestGUIExtraItems(guiPath)) {
inv.addButton(
new BInventoryButton(new ItemBuilder(plugin.getGui().getChestGUIExtraItemsItem(guiPath, str))) {
@Override
public void onClick(ClickEvent clickEvent) {
new RewardBuilder(plugin.getGui().getData(),
"CHEST." + guiPath + ".ExtraItems." + str + ".Rewards").setGiveOffline(false)
.send(clickEvent.getPlayer());
}
});
}
inv.openInventory(player);
}
@@ -12,7 +12,6 @@ import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.UpdatingBInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.misc.ArrayUtils;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import com.bencodez.advancedcore.api.rewards.RewardOptions;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.topvoter.TopVoter;
@@ -25,7 +24,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;
}
@@ -121,13 +120,19 @@ public class VoteGUI extends GUIHandler {
@Override
public void onChest(Player player) {
if (this.user == null) {
user = UserManager.getInstance().getVotingPluginUser((Player) player);
user = UserManager.getInstance().getVotingPluginUser(player);
}
BInventory inv = new BInventory(plugin.getGui().getChestVoteGUIName());
if (!plugin.getConfigFile().isAlwaysCloseInventory()) {
inv.dontClose();
}
if (player.getUniqueId().toString().equals(user.getUUID())) {
inv.requirePermission("VotingPlugin.Commands.Vote.GUI");
} else {
inv.requirePermission("VotingPlugin.Commands.Vote.GUI.Other");
}
inv.addPlaceholder("points", "" + user.getPoints());
inv.addPlaceholder("player", user.getPlayerName());
inv.addPlaceholder("top", plugin.getConfigFile().getVoteTopDefault());
@@ -171,12 +176,16 @@ public class VoteGUI extends GUIHandler {
new VoteShop(plugin, player, user).open(GUIMethod.CHEST);
} else if (slot.equalsIgnoreCase("lastmonth")) {
new VoteTopVoterLastMonth(plugin, player, user).open(GUIMethod.CHEST);
} else if (slot.equalsIgnoreCase("best")) {
new VoteBest(plugin, player, user).open(GUIMethod.CHEST);
} else if (slot.equalsIgnoreCase("streak")) {
new VoteStreak(plugin, player, user).open(GUIMethod.CHEST);
}
}
if (RewardHandler.getInstance().hasRewards(plugin.getGui().getData(),
if (plugin.getRewardHandler().hasRewards(plugin.getGui().getData(),
plugin.getGui().getChestVoteGUISlotRewardsPath(slot))) {
RewardHandler.getInstance().giveReward(UserManager.getInstance().getVotingPluginUser(player),
plugin.getRewardHandler().giveReward(UserManager.getInstance().getVotingPluginUser(player),
plugin.getGui().getData(), plugin.getGui().getChestVoteGUISlotRewardsPath(slot),
new RewardOptions().addPlaceholder("identifier", slot));
}
@@ -11,8 +11,10 @@ import com.bencodez.advancedcore.api.command.CommandHandler;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.messages.StringParser;
import com.bencodez.advancedcore.nms.NMSManager;
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 +23,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,11 +39,42 @@ 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 || cmdHandle.hasPerm(sender)) {
unsorted.put(cmdHandle.getHelpLineCommand("/vote"), cmdHandle.getHelpLine("/vote",
plugin.getConfigFile().getFormatCommandsVoteHelpLine(), hoverColor));
}
}
ArrayList<String> unsortedList = new ArrayList<String>();
unsortedList.addAll(unsorted.keySet());
Collections.sort(unsortedList, String.CASE_INSENSITIVE_ORDER);
for (String cmd : unsortedList) {
msg.add(unsorted.get(cmd));
}
return msg;
}
public ArrayList<TextComponent> helpTextLegacy(CommandSender sender) {
ArrayList<TextComponent> msg = new ArrayList<TextComponent>();
HashMap<String, TextComponent> unsorted = new HashMap<String, TextComponent>();
boolean requirePerms = plugin.getConfigFile().getFormatCommandsVoteHelpRequirePermission();
for (CommandHandler cmdHandle : plugin.getVoteCommand()) {
if (!requirePerms || cmdHandle.hasPerm(sender)) {
unsorted.put(cmdHandle.getHelpLineCommand("/vote"),
cmdHandle.getHelpLine("/vote", plugin.getConfigFile().getFormatCommandsVoteHelpLine()));
}
}
}
ArrayList<String> unsortedList = new ArrayList<String>();
unsortedList.addAll(unsorted.keySet());
@@ -76,7 +109,12 @@ public class VoteHelp extends GUIHandler {
public ArrayList<TextComponent> voteHelpText(CommandSender sender) {
int pagesize = plugin.getConfigFile().getFormatPageSize();
ArrayList<TextComponent> msg = new ArrayList<TextComponent>();
ArrayList<TextComponent> text = helpText(sender);
ArrayList<TextComponent> text = new ArrayList<TextComponent>();
if (NMSManager.getInstance().isVersion("1.12")) {
text = helpTextLegacy(sender);
} else {
text = helpText(sender);
}
int maxPage = text.size() / pagesize;
if ((text.size() % pagesize) != 0) {
@@ -8,13 +8,16 @@ 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.BInventoryButton;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.UpdatingBInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.messages.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.user.UserManager;
import com.bencodez.votingplugin.user.VotingPluginUser;
public class VoteLast extends GUIHandler {
@@ -23,7 +26,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;
}
@@ -64,22 +67,53 @@ public class VoteLast extends GUIHandler {
if (!site.isHidden()) {
inv.addButton(inv.getNextSlot(),
new UpdatingBInventoryButton(site.getItem().setName(site.getDisplayName())
.setLore(user.voteCommandLastLine(site)).setAmountNone(1), 1000, 1000) {
.setLore(user.voteCommandLastGUILine(site)).setAmountNone(1), 1000, 1000) {
@Override
public void onClick(ClickEvent clickEvent) {
public void onClick(ClickEvent event) {
if (plugin.getGui().isChestVoteLastClickableLinks()) {
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", site.getVoteURL()),
"sitename", site.getDisplayName()),
"player", player.getName()));
}
}
}
@Override
public ItemBuilder onUpdate(Player p) {
return site.getItem().setName(site.getDisplayName())
.setLore(user.voteCommandLastLine(site)).setAmountNone(1);
.setLore(user.voteCommandLastGUILine(site)).setAmountNone(1);
}
});
}
}
String guiPath = "VoteLast";
for (final String str : plugin.getGui().getChestGUIExtraItems(guiPath)) {
inv.addButton(
new BInventoryButton(new ItemBuilder(plugin.getGui().getChestGUIExtraItemsItem(guiPath, str))) {
@Override
public void onClick(ClickEvent clickEvent) {
new RewardBuilder(plugin.getGui().getData(),
"CHEST." + guiPath + ".ExtraItems." + str + ".Rewards").setGiveOffline(false)
.send(clickEvent.getPlayer());
}
});
}
if (plugin.getGui().getChestVoteLastBackButton()) {
inv.addButton(plugin.getCommandLoader().getBackButton(user));
}
@@ -11,10 +11,12 @@ import com.bencodez.advancedcore.api.bookgui.Layout;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.UpdatingBInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.messages.StringParser;
import com.bencodez.advancedcore.api.rewards.RewardBuilder;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.objects.VoteSite;
import com.bencodez.votingplugin.user.VotingPluginUser;
@@ -27,7 +29,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;
}
@@ -43,7 +45,6 @@ public class VoteNext extends GUIHandler {
for (VoteSite voteSite : plugin.getVoteSites()) {
if (!voteSite.isHidden()) {
String msgLine = plugin.getConfigFile().getFormatCommandsVoteNextLayout();
msgLine = StringParser.getInstance().replaceIgnoreCase(msgLine, "%info%",
@@ -63,12 +64,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();
@@ -85,20 +88,39 @@ 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());
}
});
}
}
String guiPath = "VoteNext";
for (final String str : plugin.getGui().getChestGUIExtraItems(guiPath)) {
inv.addButton(
new BInventoryButton(new ItemBuilder(plugin.getGui().getChestGUIExtraItemsItem(guiPath, str))) {
@Override
public void onClick(ClickEvent clickEvent) {
new RewardBuilder(plugin.getGui().getData(),
"CHEST." + guiPath + ".ExtraItems." + str + ".Rewards").setGiveOffline(false)
.send(clickEvent.getPlayer());
}
});
}
if (plugin.getGui().getChestVoteNextBackButton()) {
@@ -13,7 +13,6 @@ import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.messages.StringParser;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import com.bencodez.advancedcore.api.rewards.RewardOptions;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.user.UserManager;
@@ -25,7 +24,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;
}
@@ -51,7 +50,11 @@ public class VoteShop extends GUIHandler {
return;
}
if (this.user == null) {
user = plugin.getVotingPluginUserManager().getVotingPluginUser(player);
}
BInventory inv = new BInventory(plugin.getGui().getChestVoteShopName());
inv.addPlaceholder("points", "" + user.getPoints());
inv.dontClose();
for (final String identifier : plugin.getGui().getChestShopIdentifiers()) {
@@ -61,14 +64,17 @@ public class VoteShop extends GUIHandler {
if (perm.isEmpty()) {
hasPerm = true;
} else {
hasPerm = player.hasPermission(perm);
if (perm.startsWith("!")) {
hasPerm = !player.hasPermission(perm.substring(1));
} else {
hasPerm = player.hasPermission(perm);
}
}
int limit = plugin.getGui().getChestShopIdentifierLimit(identifier);
boolean limitPass = true;
if (limit > 0) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(player);
if (user.getVoteShopIdentifierLimit(identifier) >= limit) {
limitPass = false;
}
@@ -85,16 +91,14 @@ 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);
if (identifier != null) {
if (plugin.getGui().getChestVoteShopCloseGUI(identifier)) {
event.getButton().getInv().closeInv(player, null);
event.closeInventory();
}
// limit fail-safe, should never be needed, except in rare cases
@@ -113,13 +117,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.getRewardHandler().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);
@@ -130,7 +137,7 @@ public class VoteShop extends GUIHandler {
}
} else {
new VoteShopConfirm(plugin, player, user, identifier).open(GUIMethod.CHEST);
;
}
} else {
user.sendMessage(plugin.getGui().getChestVoteShopLimitReached());
@@ -14,7 +14,6 @@ import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.messages.StringParser;
import com.bencodez.advancedcore.api.misc.PlayerUtils;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import com.bencodez.advancedcore.api.rewards.RewardOptions;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.user.VotingPluginUser;
@@ -26,7 +25,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 +48,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,8 +61,10 @@ 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.getRewardHandler().giveReward(user, plugin.getGui().getData(),
plugin.getGui().getChestShopIdentifierRewardsPath(identifier),
new RewardOptions().setPlaceholders(placeholders));
@@ -77,7 +80,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();
}
}
@@ -89,7 +92,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();
}
}
});
@@ -13,6 +13,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.advancedcore.api.misc.ArrayUtils;
import com.bencodez.advancedcore.api.rewards.RewardBuilder;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.user.VotingPluginUser;
@@ -23,7 +24,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;
}
@@ -118,6 +119,21 @@ public class VoteStreak extends GUIHandler {
}
});
String guiPath = "VoteStreak";
for (final String str : plugin.getGui().getChestGUIExtraItems(guiPath)) {
inv.addButton(
new BInventoryButton(new ItemBuilder(plugin.getGui().getChestGUIExtraItemsItem(guiPath, str))) {
@Override
public void onClick(ClickEvent clickEvent) {
new RewardBuilder(plugin.getGui().getData(),
"CHEST." + guiPath + ".ExtraItems." + str + ".Rewards").setGiveOffline(false)
.send(clickEvent.getPlayer());
}
});
}
if (plugin.getGui().getChestVoteStreakBackButton()) {
inv.addButton(plugin.getCommandLoader().getBackButton(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,11 @@ 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.api.rewards.RewardBuilder;
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 +33,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;
@@ -54,11 +56,11 @@ public class VoteToday extends GUIHandler {
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++) {
@@ -84,7 +86,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());
@@ -103,18 +105,33 @@ 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()));
}
});
}
}
String guiPath = "VoteToday";
for (final String str : plugin.getGui().getChestGUIExtraItems(guiPath)) {
inv.addButton(
new BInventoryButton(new ItemBuilder(plugin.getGui().getChestGUIExtraItemsItem(guiPath, str))) {
@Override
public void onClick(ClickEvent clickEvent) {
new RewardBuilder(plugin.getGui().getData(),
"CHEST." + guiPath + ".ExtraItems." + str + ".Rewards").setGiveOffline(false)
.send(clickEvent.getPlayer());
}
});
}
if (plugin.getGui().getChestVoteTodayBackButton()) {
inv.addButton(plugin.getCommandLoader().getBackButton(user));
@@ -129,7 +146,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());
@@ -150,7 +167,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,8 +85,8 @@ public class VoteTopVoter extends GUIHandler {
}
int pos = 1;
for (Entry<VotingPluginUser, Integer> entry : users) {
ItemBuilder playerItem;
for (Entry<TopVoterPlayer, Integer> entry : users) {
ItemBuilder playerItem = new ItemBuilder(Material.PAPER);
if (plugin.getGui().isChestVoteTopUseSkull()) {
playerItem = new ItemBuilder(entry.getKey().getPlayerHead());
@@ -103,8 +104,8 @@ public class VoteTopVoter extends GUIHandler {
@Override
public void onClick(ClickEvent clickEvent) {
if (plugin.getGui().getChestVoteTopOpenMainGUIOnClick()) {
VotingPluginUser user = (VotingPluginUser) getData("User");
new VoteGUI(plugin, player, user)
TopVoterPlayer user = (TopVoterPlayer) getData("User");
new VoteGUI(plugin, player, user.getUser())
.open(GUIMethod.valueOf(plugin.getGui().getGuiMethodGUI().toUpperCase()));
} else {
getInv().forceClose(clickEvent.getPlayer());
@@ -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()) {
@@ -73,8 +74,8 @@ public class VoteTopVoterLastMonth extends GUIHandler {
@Override
public void onClick(ClickEvent clickEvent) {
VotingPluginUser user = (VotingPluginUser) getData("User");
new VoteGUI(plugin, player, user)
TopVoterPlayer user = (TopVoterPlayer) getData("User");
new VoteGUI(plugin, player, user.getUser())
.open(GUIMethod.valueOf(plugin.getGui().getGuiMethodGUI().toUpperCase()));
}
}.addData("player", entry.getKey().getPlayerName()).addData("User", entry.getKey()));
@@ -8,23 +8,24 @@ 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.BInventoryButton;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.UpdatingBInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.messages.StringParser;
import com.bencodez.advancedcore.api.misc.ArrayUtils;
import com.bencodez.advancedcore.api.rewards.RewardBuilder;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.topvoter.TopVoter;
import com.bencodez.votingplugin.user.VotingPluginUser;
public class VoteTotal extends GUIHandler {
@SuppressWarnings("unused")
private VotingPluginMain plugin;
private VotingPluginUser user;
public VoteTotal(VotingPluginMain plugin, CommandSender player, VotingPluginUser user) {
super(player);
super(plugin, player);
this.plugin = plugin;
this.user = user;
}
@@ -85,6 +86,21 @@ public class VoteTotal extends GUIHandler {
});
}
String guiPath = "VoteTotal";
for (final String str : plugin.getGui().getChestGUIExtraItems(guiPath)) {
inv.addButton(
new BInventoryButton(new ItemBuilder(plugin.getGui().getChestGUIExtraItemsItem(guiPath, str))) {
@Override
public void onClick(ClickEvent clickEvent) {
new RewardBuilder(plugin.getGui().getData(),
"CHEST." + guiPath + ".ExtraItems." + str + ".Rewards").setGiveOffline(false)
.send(clickEvent.getPlayer());
}
});
}
if (plugin.getGui().getChestVoteTotalBackButton()) {
inv.addButton(plugin.getCommandLoader().getBackButton(user));
}
@@ -13,8 +13,8 @@ import com.bencodez.advancedcore.api.bookgui.Layout;
import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.inventory.UpdatingBInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.messages.MessageBuilder;
@@ -36,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;
@@ -115,17 +115,17 @@ public class VoteURL extends GUIHandler {
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()));
builder.setName(
plugin.getGui().getChestVoteURLGUISiteNameCanVote().replace("%Name%", voteSite.getDisplayName()));
} else {
builder.setName(plugin.getGui().getChestVoteURLGUISiteName().replace("%Name%", voteSite.getDisplayName()));
builder.addLoreLine(
plugin.getGui().getChestVoteURLNextVote().replace("%Info%", user.voteCommandNextInfo(voteSite)));
}
return builder;
}
@@ -165,7 +165,7 @@ public class VoteURL extends GUIHandler {
if (plugin.getGui().getChestVoteURLViewAllUrlsButtonEnabled()) {
ItemBuilder builderAll = getItemAll();
inv.addButton(new UpdatingBInventoryButton(builderAll, 1000, 1000) {
inv.addButton(new UpdatingBInventoryButton(builderAll, 5000, 5000) {
@Override
public void onClick(ClickEvent event) {
@@ -190,7 +190,7 @@ public class VoteURL extends GUIHandler {
startSlot++;
}
inv.addButton(new UpdatingBInventoryButton(builder, 1000, 1000) {
inv.addButton(new UpdatingBInventoryButton(builder, 5000, 5000) {
@Override
public void onClick(ClickEvent event) {
@@ -223,7 +223,7 @@ public class VoteURL extends GUIHandler {
public void onClick(ClickEvent clickEvent) {
new RewardBuilder(plugin.getGui().getData(), "CHEST.VoteURL.ExtraItems." + str + ".Rewards")
.setGiveOffline(false).send(clickEvent.getPlayer());
;
}
});
}
@@ -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);
@@ -1,11 +1,13 @@
package com.bencodez.votingplugin.config;
import java.io.File;
import java.util.ArrayList;
import com.bencodez.advancedcore.api.yml.YMLFile;
import com.bencodez.advancedcore.api.yml.annotation.AnnotationHandler;
import com.bencodez.advancedcore.api.yml.annotation.ConfigDataBoolean;
import com.bencodez.advancedcore.api.yml.annotation.ConfigDataInt;
import com.bencodez.advancedcore.api.yml.annotation.ConfigDataListString;
import com.bencodez.advancedcore.api.yml.annotation.ConfigDataString;
import com.bencodez.votingplugin.VotingPluginMain;
@@ -25,14 +27,6 @@ public class BungeeSettings extends YMLFile {
@Getter
private boolean bungeeDebug = false;
@ConfigDataBoolean(path = "VotifierBypass")
@Getter
private boolean votifierBypass = false;
@ConfigDataBoolean(path = "TriggerVotifierEvent")
@Getter
private boolean triggerVotifierEvent = false;
@ConfigDataString(path = "BungeeMethod")
@Getter
private String bungeeMethod = "PLUGINMESSAGING";
@@ -45,14 +39,22 @@ public class BungeeSettings extends YMLFile {
@Getter
private int bungeeServerPort = 1297;
@ConfigDataBoolean(path = "RemoveInvalidUsers")
@ConfigDataBoolean(path = "PerServerPoints")
@Getter
private boolean removeInvalidUsers = false;
private boolean perServerPoints = false;
@ConfigDataBoolean(path = "PerServerMilestones")
@Getter
private boolean perServerMilestones = false;
@ConfigDataBoolean(path = "PerServerRewards")
@Getter
private boolean perServerRewards = false;
@ConfigDataBoolean(path = "RemoveInvalidUsers")
@Getter
private boolean removeInvalidUsers = false;
@ConfigDataString(path = "Server")
@Getter
private String server = "PleaseSet";
@@ -65,14 +67,42 @@ 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;
@ConfigDataBoolean(path = "DisableBroadcast")
@Getter
private boolean disableBroadcast = false;
@ConfigDataBoolean(path = "GlobalData.UseMainMySQL")
@Getter
private boolean globlalDataUseMainMySQL = true;
@ConfigDataBoolean(path = "GlobalData.Enabled")
@Getter
private boolean globlalDataEnabled = false;
@ConfigDataListString(path = "BungeeVotePartyGlobalCommands")
@Getter
private ArrayList<String> bungeeVotePartyGlobalCommands = new ArrayList<String>();
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);
@@ -15,6 +15,7 @@ import com.bencodez.advancedcore.api.yml.annotation.ConfigDataInt;
import com.bencodez.advancedcore.api.yml.annotation.ConfigDataListString;
import com.bencodez.advancedcore.api.yml.annotation.ConfigDataString;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.placeholders.PlaceholderCacheLevel;
import com.bencodez.votingplugin.topvoter.TopVoter;
import lombok.Getter;
@@ -33,30 +34,34 @@ public class Config extends YMLFile {
@Getter
private boolean addTotals = true;
@ConfigDataBoolean(path = "PerSiteCoolDownEvents")
@Getter
private boolean perSiteCoolDownEvents = false;
@ConfigDataBoolean(path = "QueueVotesDuringTimeChange")
@Getter
private boolean queueVotesDuringTimeChange = false;
@ConfigDataBoolean(path = "AllowUnjoined")
@Getter
private boolean allowUnjoined = false;
@ConfigDataBoolean(path = "UseVoteGUIMainCommand")
@ConfigDataBoolean(path = "PreloadSkulls")
@Getter
private boolean useVoteGUIMainCommand = false;
@ConfigDataBoolean(path = "ExtraAllSitesCheck")
@Getter
private boolean extraAllSitesCheck = false;
private boolean preloadSkulls = false;
@ConfigDataBoolean(path = "AllowUnJoinedCheckServer")
@Getter
private boolean allowUnJoinedCheckServer = true;
@ConfigDataInt(path = "PlayerDataLoadLimit")
@Getter
private int playerDataLoadLimit = -1;
@ConfigDataBoolean(path = "AllowVotePointTransfers")
@Getter
private boolean allowVotePointTransfers = false;
@ConfigDataBoolean(path = "AlterColumns")
@Getter
private boolean alterColumns = true;
@ConfigDataBoolean(path = "AlternateUUIDLookup")
@Getter
private boolean alternateUUIDLookup = false;
@@ -77,26 +82,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;
@@ -109,6 +94,10 @@ public class Config extends YMLFile {
@Getter
private boolean disableAdvancedTab = false;
@ConfigDataBoolean(path = "DisableCoolDownCheck")
@Getter
private boolean disableCoolDownCheck = false;
@ConfigDataListString(path = "DisabledCommands")
@Getter
private ArrayList<String> disabledCommands = new ArrayList<String>();
@@ -117,6 +106,14 @@ public class Config extends YMLFile {
@Getter
private ArrayList<String> disabledDefaultPermissions = new ArrayList<String>();
@ConfigDataListString(path = "CachedPlaceholders")
@Getter
private ArrayList<String> cachedPlaceholders = new ArrayList<String>();
@ConfigDataBoolean(path = "DisableInteractEvent")
@Getter
private boolean disableInteractEvent = false;
@ConfigDataBoolean(path = "DisableNoServiceSiteMessage")
@Getter
private boolean disableNoServiceSiteMessage = false;
@@ -125,22 +122,18 @@ public class Config extends YMLFile {
@Getter
private boolean disableUpdateChecking = false;
@ConfigDataBoolean(path = "ExtraAllSitesCheck")
@Getter
private boolean extraAllSitesCheck = false;
@ConfigDataBoolean(path = "CloseInventoryOnVote")
@Getter
private boolean closeInventoryOnVote = true;
@ConfigDataBoolean(path = "ExtraBackgroundUpdate")
@Getter
private boolean extraBackgroundUpdate = false;
@ConfigDataBoolean(path = "Format.Commands.Vote.ForceLinks")
@Getter
private boolean formatCommandsVoteForceLinks = true;
@ConfigDataBoolean(path = "DisableInteractEvent")
@Getter
private boolean disableInteractEvent = false;
@ConfigDataString(path = "Format.Commands.Vote.Last.LastVoted")
@Getter
private String formatCommandsVoteLastLastVoted = "%times% ago";
@ConfigDataString(path = "Format.AlternateBroadcast.Broadcast")
@Getter
private String formatAlternateBroadcastBroadcast = "&6[&4Broadcast&6] &2%numberofplayers% voted in the last half hour! /vote";
@@ -153,6 +146,22 @@ public class Config extends YMLFile {
@Getter
private boolean formatAlternateBroadcastEnabled = false;
@ConfigDataBoolean(path = "Format.OnlyOneOfflineBroadcast")
@Getter
private boolean formatOnlyOneOfflineBroadcast = false;
@ConfigDataString(path = "Format.OfflineBroadcast")
@Getter
private String formatOfflineBroadcast = "&6[&4Broadcast&6] &2Thanks &c%player% &2for voting on %numberofvotes% times!";
@ConfigDataBoolean(path = "Format.Commands.Vote.ForceLinks")
@Getter
private boolean formatCommandsVoteForceLinks = true;
@ConfigDataString(path = "Format.Commands.Vote.Last.LastVoted")
@Getter
private String formatCommandsVoteLastLastVoted = "%times% ago";
@ConfigDataString(path = "Format.Commands.Vote.Last.Line", defaultValue = "&3%SiteName%: &6%timeSince% ago")
@Getter
private String formatCommandsVoteLastLine;
@@ -182,6 +191,14 @@ public class Config extends YMLFile {
@Getter
private String formatCommandsVoteToggleBroadcastEnabled = "&cYou will now see vote broadcasts";
@ConfigDataString(path = "Format.Commands.Vote.ToggleReminders.Disabled")
@Getter
private String formatCommandsVoteToggleRemindersDisabled = "&cVote reminders disabled";
@ConfigDataString(path = "Format.Commands.Vote.ToggleReminders.Enabled")
@Getter
private String formatCommandsVoteToggleRemindersEnabled = "&cVote reminders enabled";
@Getter
private int formatPageSize = 10;
@@ -231,11 +248,7 @@ public class Config extends YMLFile {
@ConfigDataInt(path = "MaxiumNumberOfTopVotersToLoad")
@Getter
private int MaxiumNumberOfTopVotersToLoad = -1;
@ConfigDataInt(path = "DelayLoginEvent")
@Getter
private int delayLoginEvent = 0;
private int MaxiumNumberOfTopVotersToLoad = 1000;
@ConfigDataBoolean(path = "OverrideVersionDisable")
@Getter
@@ -249,6 +262,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;
@@ -257,9 +274,13 @@ public class Config extends YMLFile {
@Getter
private boolean usePrimaryAccountForPlaceholders = false;
@ConfigDataBoolean(path = "DisableCoolDownCheck")
@ConfigDataBoolean(path = "UseVoteGUIMainCommand")
@Getter
private boolean disableCoolDownCheck = false;
private boolean useVoteGUIMainCommand = false;
@ConfigDataBoolean(path = "UseVoteStreaks")
@Getter
private boolean useVoteStreaks = true;
@ConfigDataListString(path = "VotingBroadcastBlacklist")
@Getter
@@ -329,6 +350,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.
*
@@ -400,6 +425,10 @@ public class Config extends YMLFile {
"%hours% Hours and %minutes% Minutes");
}
public PlaceholderCacheLevel getPlaceholderCacheLevel() {
return PlaceholderCacheLevel.getCache(getData().getString("PlaceholderCacheLevel", "AUTO"));
}
/**
* Gets the commands vote next layout.
*
@@ -677,14 +706,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);
}
@@ -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);
}
@@ -127,12 +130,12 @@ public class ConfigVoteSites extends YMLFile {
* @param siteName the site name
* @return the vote delay
*/
public int getVoteDelay(String siteName) {
return getData(siteName).getInt("VoteDelay", 24);
public double getVoteDelay(String siteName) {
return getData(siteName).getDouble("VoteDelay", 24);
}
public int getVoteDelayMin(String siteName) {
return getData(siteName).getInt("VoteDelayMin", 0);
public double getVoteDelayMin(String siteName) {
return getData(siteName).getDouble("VoteDelayMin", 0);
}
/**
@@ -144,14 +147,6 @@ public class ConfigVoteSites extends YMLFile {
public boolean getVoteSiteEnabled(String siteName) {
return getData(siteName).getBoolean("Enabled");
}
public boolean getVoteSiteHidden(String siteName) {
return getData(siteName).getBoolean("Hidden");
}
public boolean getVoteSiteIgnoreCanVote(String siteName) {
return getData(siteName).getBoolean("IgnoreCanVote");
}
/**
* Gets the vote site file.
@@ -178,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");
}
@@ -189,14 +192,16 @@ 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")) {
if (!siteCheck(site)) {
plugin.getLogger().warning("Failed to load site " + site + ", see above");
} else {
voteSites.add(new VoteSite(plugin, site));
VoteSite voteSite = new VoteSite(plugin, site);
plugin.debug(voteSite.loadingDebug());
voteSites.add(voteSite);
}
}
}
@@ -222,12 +227,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));
@@ -235,11 +235,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);
}
}
@@ -392,7 +395,7 @@ public class ConfigVoteSites extends YMLFile {
* @param siteName the site name
* @param voteDelay the vote delay
*/
public void setVoteDelay(String siteName, int voteDelay) {
public void setVoteDelay(String siteName, double voteDelay) {
set(siteName, "VoteDelay", voteDelay);
}
@@ -74,6 +74,10 @@ public class GUI extends YMLFile {
@Getter
private boolean chestVoteShopRequireConfirmation = false;
@ConfigDataBoolean(path = "CHEST.VoteBest.BackButton")
@Getter
private boolean chestVoteBestBackButton = true;
@ConfigDataString(path = "CHEST.VoteToday.IconTitle")
@Getter
private String chestVoteTodayIconTitle = "%player%";
@@ -142,18 +146,33 @@ public class GUI extends YMLFile {
@Getter
private boolean lastMonthGUI = false;
private VotingPluginMain plugin;
@ConfigDataBoolean(path = "CHEST.VoteLast.ClickableLinks")
@Getter
private boolean chestVoteLastClickableLinks = true;
public String getCHESTVoteShopPurchase(String identifier) {
return getData().getString("CHEST.Shop." + identifier + ".PurchaseMessage",
plugin.getConfigFile().getFormatShopPurchaseMsg());
}
private VotingPluginMain plugin;
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");
}
@@ -218,10 +237,6 @@ public class GUI extends YMLFile {
return getData().getString("CHEST.VoteGUI." + slot + ".Command", "");
}
public String getChestVoteGUISlotRewardsPath(String slot) {
return "CHEST.VoteGUI." + slot + ".Rewards";
}
/**
* Gets the vote GUI slot lore.
*
@@ -233,6 +248,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.
*
@@ -264,6 +283,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%");
}
@@ -304,6 +327,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);
}
@@ -368,14 +396,14 @@ public class GUI extends YMLFile {
return getData().getString("CHEST.VoteTop.Item.Name", "&3&l%position%: &3%player%");
}
public boolean getChestVoteTopOpenMainGUIOnClick() {
return getData().getBoolean("CHEST.VoteTop.OpenMainGUIOnClick", true);
}
public String getChestVoteTopName() {
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);
}
@@ -424,6 +452,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");
@@ -436,25 +472,6 @@ public class GUI extends YMLFile {
return getData().getConfigurationSection("CHEST.VoteURL.AlreadyVotedItem");
}
public int getChestVoteURLAllUrlsButtonSlot() {
return getData().getInt("CHEST.VoteURL.AllUrlsButton.Slot", -1);
}
public int getChestVoteURLAllUrlsButtonStartSlot() {
return getData().getInt("CHEST.VoteURL.StartSlot", -1);
}
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);
}
public boolean getChestVoteURLBackButton() {
return getData().getBoolean("CHEST.VoteURL.BackButton");
}
@@ -471,6 +488,28 @@ 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);
}
public Set<String> getChestGUIExtraItems(String gui) {
if (getData().isConfigurationSection("CHEST." + gui + ".ExtraItems")) {
return getData().getConfigurationSection("CHEST." + gui + ".ExtraItems").getKeys(false);
}
return new HashSet<String>();
}
public ConfigurationSection getChestGUIExtraItemsItem(String gui, String item) {
return getData().getConfigurationSection("CHEST." + gui + ".ExtraItems." + item);
}
/**
* Gets the vote URL site name.
*
@@ -524,6 +563,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);
@@ -534,27 +578,6 @@ 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 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 void removeShop(String value) {
getData().set("CHEST.Shop." + value, null);
saveData();
@@ -3,6 +3,7 @@ package com.bencodez.votingplugin.config;
import java.io.File;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import com.bencodez.advancedcore.api.yml.YMLFile;
@@ -10,6 +11,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;
@@ -18,6 +20,9 @@ public class SpecialRewardsConfig extends YMLFile {
@Getter
private String allSitesRewardPath = "AllSites";
@Getter
private String almostAllSitesRewardPath = "AlmostAllSites";
@Getter
private String anySiteRewardsPath = "AnySiteRewards";
@@ -33,20 +38,31 @@ public class SpecialRewardsConfig extends YMLFile {
@Getter
private boolean enableWeeklyAwards = false;
@ConfigDataBoolean(path = "OnlyOneCumulative")
@Getter
private boolean onlyOneCumulative = false;
@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";
@@ -79,6 +95,14 @@ public class SpecialRewardsConfig extends YMLFile {
return "Cumulative." + cumulative + ".Rewards";
}
public List<Integer> getCumulativeBlackList(int cumulative) {
return getData().getIntegerList("Cumulative." + cumulative + ".BlackList");
}
public boolean getCumulativeRecurring(int cumulative) {
return getData().getBoolean("Cumulative." + cumulative + ".Recurring", true);
}
/**
* Gets the cumulative votes.
*
@@ -102,18 +126,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";
}
@@ -195,8 +236,9 @@ public class SpecialRewardsConfig extends YMLFile {
}
@SuppressWarnings("unchecked")
public ArrayList<String> getVotePartyCommands() {
return (ArrayList<String>) getData().getList("VoteParty.Commands", new ArrayList<String>());
public ArrayList<String> getVotePartyGlobalCommands() {
return (ArrayList<String>) getData().getList("VoteParty.GlobalCommands",
(ArrayList<String>) getData().getList("VoteParty.Commands", new ArrayList<String>()));
}
public boolean getVotePartyCountFakeVotes() {
@@ -229,14 +271,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 getVotePartyOnlyOncePerWeek() {
return getData().getBoolean("VoteParty.OnlyOncePerWeek");
}
public boolean getVotePartyResetEachDay() {
return getData().getBoolean("VoteParty.ResetEachDay");
}
public boolean getVotePartyResetMontly() {
return getData().getBoolean("VoteParty.ResetMonthly");
}
@@ -305,9 +351,8 @@ public class SpecialRewardsConfig extends YMLFile {
plugin.saveResource("SpecialRewards.yml", true);
}
public void setMilestone(int intValue) {
getData().set("Milestones." + intValue + ".Enabled", true);
getData().set("Milestones." + intValue + ".Rewards.Messages.Player", "&aYou got %milestone% milestone votes!");
public void removeCumulative(String votes) {
getData().set("Cumulative." + votes, null);
saveData();
}
@@ -316,14 +361,17 @@ public class SpecialRewardsConfig extends YMLFile {
saveData();
}
public void removeCumulative(String votes) {
getData().set("Cumulative." + votes, null);
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 setCumulative(int intValue) {
getData().set("Cumulative." + intValue + ".Enabled", true);
getData().set("Cumulative." + intValue + ".Rewards.Messages.Player", "&aYou got %cumulative% cumulative votes!");
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,86 +1,186 @@
package com.bencodez.votingplugin.cooldown;
import java.util.TimerTask;
import java.util.HashMap;
import java.util.UUID;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
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.events.PlayerVoteSiteCoolDownEndEvent;
import com.bencodez.votingplugin.objects.VoteSite;
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 HashMap<UUID, ScheduledFuture<?>> perSiteTasks = new HashMap<UUID, ScheduledFuture<?>>();
private HashMap<UUID, ScheduledFuture<?>> allSiteTasks = new HashMap<UUID, ScheduledFuture<?>>();
public CoolDownCheck(VotingPluginMain plugin) {
this.plugin = plugin;
this.timer = Executors.newScheduledThreadPool(1);
}
public void load() {
checkAll();
}
private ScheduledExecutorService timer;
public void checkAll() {
if (!plugin.getConfigFile().isDisableCoolDownCheck() && RewardHandler.getInstance()
private boolean cooldownCheckEnabled = false;
public void checkEnabled() {
if (!plugin.getConfigFile().isDisableCoolDownCheck() && plugin.getRewardHandler()
.hasRewards(plugin.getSpecialRewardsConfig().getData(), "VoteCoolDownEndedReward")) {
plugin.getTimer().schedule(new TimerTask() {
cooldownCheckEnabled = true;
} else {
cooldownCheckEnabled = false;
}
}
public void check(UUID uuid) {
check(plugin.getVotingPluginUserManager().getVotingPluginUser(uuid));
}
public void checkPerSite(UUID uuid) {
checkPerSite(plugin.getVotingPluginUserManager().getVotingPluginUser(uuid));
}
public void vote(VotingPluginUser user, VoteSite site) {
if (cooldownCheckEnabled) {
schedule(user);
}
if (plugin.getConfigFile().isPerSiteCoolDownEvents()) {
user.setCoolDownCheckSite(site, Boolean.FALSE);
schedulePerSite(user);
}
}
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);
allSiteTasks.remove(user.getJavaUUID());
} else if (!coolDownCheck) {
schedule(user);
}
}
public synchronized void checkPerSite(VotingPluginUser user) {
if (plugin.getConfigFile().isPerSiteCoolDownEvents()) {
HashMap<VoteSite, Boolean> coolDownChecks = user.getCoolDownCheckSiteList();
boolean changed = false;
for (VoteSite site : plugin.getVoteSites()) {
if (user.canVoteSite(site)) {
if (!coolDownChecks.containsKey(site) || !coolDownChecks.get(site).booleanValue()) {
coolDownChecks.put(site, Boolean.TRUE);
changed = true;
PlayerVoteSiteCoolDownEndEvent event = new PlayerVoteSiteCoolDownEndEvent(user, site);
plugin.getServer().getPluginManager().callEvent(event);
}
}
}
if (changed) {
user.setCoolDownCheckSite(coolDownChecks);
}
}
schedulePerSite(user);
}
public void schedulePerSite(VotingPluginUser user) {
final UUID uuid = UUID.fromString(user.getUUID());
long time = user.getNextTimeFirstSiteAvailable();
if (time > 0) {
if (perSiteTasks.containsKey(uuid)) {
perSiteTasks.get(uuid).cancel(false);
perSiteTasks.remove(uuid);
}
plugin.devDebug("PerSiteCoolDownEvent schedule time: " + time);
ScheduledFuture<?> scheduledFuture = timer.schedule(new Runnable() {
@Override
public void run() {
if (VotingPluginMain.plugin != null) {
if (!plugin.getConfigFile().isDisableCoolDownCheck() && RewardHandler.getInstance()
.hasRewards(plugin.getSpecialRewardsConfig().getData(), "VoteCoolDownEndedReward")) {
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 {
plugin.debug("Not enabling cooldown check reward");
cancel();
}
} else {
cancel();
if (plugin != null && plugin.isEnabled()) {
checkPerSite(uuid);
}
}
}, 1000 * 60 * 5, 1000 * 60 * 30);
} else {
plugin.debug("Not enabling cooldown check reward");
}, time + 2, TimeUnit.SECONDS);
perSiteTasks.put(uuid, scheduledFuture);
}
}
@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()));
public void schedule(VotingPluginUser user) {
final UUID uuid = UUID.fromString(user.getUUID());
long time = user.getNextTimeAllSitesAvailable();
if (time > 0) {
user.setCoolDownCheck(true);
if (allSiteTasks.containsKey(uuid)) {
allSiteTasks.get(uuid).cancel(false);
allSiteTasks.remove(uuid);
}
ScheduledFuture<?> scheduledFuture = timer.schedule(new Runnable() {
@Override
public void run() {
check(uuid);
}
}, time + 2, TimeUnit.SECONDS);
allSiteTasks.put(uuid, scheduledFuture);
}
}
public void load() {
plugin.addUserStartup(new UserStartup() {
@Override
public void onStartUp(AdvancedCoreUser advancedcoreUser) {
VotingPluginUser user = plugin.getVotingPluginUserManager().getVotingPluginUser(advancedcoreUser);
if (cooldownCheckEnabled) {
check(user);
}
if (plugin.getConfigFile().isPerSiteCoolDownEvents()) {
checkPerSite(user);
}
}
@Override
public void onStart() {
}
@Override
public void onFinish() {
}
});
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onDayChangeEnd(DateChangedEvent event) {
checkAll();
public void onCoolDownEnd(PlayerVoteCoolDownEndEvent event) {
plugin.getRewardHandler().giveReward(event.getPlayer(), plugin.getSpecialRewardsConfig().getData(),
"VoteCoolDownEndedReward", new RewardOptions());
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onCoolDownEnd(PlayerVoteSiteCoolDownEndEvent event) {
plugin.getRewardHandler().giveReward(event.getPlayer(), event.getSite().getSiteData(), "CoolDownEndRewards",
new RewardOptions());
}
}
@@ -1,7 +1,10 @@
package com.bencodez.votingplugin.data;
import java.time.temporal.WeekFields;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Set;
import org.bukkit.Bukkit;
@@ -11,6 +14,7 @@ import org.bukkit.configuration.ConfigurationSection;
import com.bencodez.advancedcore.api.misc.ArrayUtils;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.signs.SignHandler;
import com.bencodez.votingplugin.timequeue.VoteTimeQueue;
// TODO: Auto-generated Javadoc
/**
@@ -24,6 +28,23 @@ public class ServerData {
this.plugin = plugin;
}
public void addAutoCachedPlaceholder(String placeholder) {
List<String> p = getAutoCachedPlaceholder();
if (!ArrayUtils.getInstance().containsIgnoreCase(p, placeholder)) {
p.add(placeholder);
setAutoCachedPlaceholder(p);
}
}
public void setAutoCachedPlaceholder(List<String> placeholders) {
getData().set("AutoCachePlaceholders", placeholders);
saveData();
}
public List<String> getAutoCachedPlaceholder() {
return getData().getStringList("AutoCachePlaceholders");
}
public synchronized void addServiceSite(String site) {
ArrayList<String> l = getServiceSites();
if (!getServiceSites().contains(site)) {
@@ -137,6 +158,23 @@ 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;
}
public boolean isLastVotePartySameWeek() {
int num = getData().getInt("LastVotePartyWeek", -1);
if (num == plugin.getTimeChecker().getTime().get(WeekFields.of(Locale.getDefault()).weekOfYear())
&& num != -1) {
return true;
}
return false;
}
/**
* Next sign number.
*
@@ -233,6 +271,35 @@ public class ServerData {
saveData();
}
public void updateLastVoteParty() {
getData().set("LastVoteParty", plugin.getTimeChecker().getTime().getDayOfYear());
saveData();
}
public void updateLastVotePartyWeek() {
getData().set("LastVotePartyWeek",
plugin.getTimeChecker().getTime().get(WeekFields.of(Locale.getDefault()).weekOfYear()));
saveData();
}
public int getBungeeVotePartyCurrent() {
return getData().getInt("BungeeVotePartyCurrent");
}
public int getBungeeVotePartyRequired() {
return getData().getInt("BungeeVotePartyRequired");
}
public void setBungeeVotePartyCurrent(int current) {
getData().set("BungeeVotePartyCurrent", current);
saveData();
}
public void setBungeeVotePartyRequired(int required) {
getData().set("BungeeVotePartyRequired", required);
saveData();
}
/**
* Update values.
*/
@@ -240,16 +307,27 @@ public class ServerData {
setVersion();
}
public boolean isLastVotePartySameDay() {
int num = getData().getInt("LastVoteParty", 0);
if (num != plugin.getTimeChecker().getTime().getDayOfYear()) {
return true;
}
return false;
public void addTimeVoted(int num, VoteTimeQueue vote) {
getData().set("TimedVoteCache." + num + ".Name", vote.getName());
getData().set("TimedVoteCache." + num + ".Service", vote.getService());
getData().set("TimedVoteCache." + num + ".Time", vote.getTime());
saveData();
}
public void updateLastVoteParty() {
getData().set("LastVoteParty", plugin.getTimeChecker().getTime().getDayOfYear());
public Set<String> getTimedVoteCacheKeys() {
if (getData().isConfigurationSection("TimedVoteCache")) {
return getData().getConfigurationSection("TimedVoteCache").getKeys(false);
} else {
return new HashSet<String>();
}
}
public ConfigurationSection getTimedVoteCacheSection(String num) {
return getData().getConfigurationSection("TimedVoteCache." + num);
}
public void clearTimedVoteCache() {
getData().set("TimedVoteCache", null);
saveData();
}
}
@@ -0,0 +1,81 @@
package com.bencodez.votingplugin.events;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import com.bencodez.votingplugin.bungee.BungeeMessageData;
import com.bencodez.votingplugin.objects.VoteSite;
import com.bencodez.votingplugin.user.VotingPluginUser;
import lombok.Getter;
import lombok.Setter;
// TODO: Auto-generated Javadoc
/**
* The Class PlayerVoteEvent.
*/
public class PlayerPostVoteEvent extends Event {
/** The Constant handlers. */
private static final HandlerList handlers = new HandlerList();
/**
* Gets the handler list.
*
* @return the handler list
*/
public static HandlerList getHandlerList() {
return handlers;
}
@Getter
@Setter
private boolean bungee = false;
@Getter
@Setter
private BungeeMessageData bungeeTextTotals;
@Getter
@Setter
private boolean cancelled;
@Getter
@Setter
private boolean forceBungee = false;
@Getter
@Setter
private VotingPluginUser user;
@Getter
@Setter
private boolean realVote = true;
@Getter
@Setter
private VoteSite voteSite;
@Getter
@Setter
private VotingPluginUser votingPluginUser;
public PlayerPostVoteEvent(VoteSite voteSite, VotingPluginUser user, boolean realVote, boolean forceBungee) {
super(true);
this.user = user;
this.voteSite = voteSite;
this.realVote = realVote;
this.forceBungee = forceBungee;
}
/*
* (non-Javadoc)
*
* @see org.bukkit.event.Event#getHandlers()
*/
@Override
public HandlerList getHandlers() {
return handlers;
}
}
@@ -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;
}
/*
@@ -71,11 +71,19 @@ public class PlayerVoteEvent extends Event {
@Getter
@Setter
private VotingPluginUser votingPluginUser;
@Getter
@Setter
private boolean wasOnline;
@Getter
@Setter
private boolean broadcast = true;
@Getter
@Setter
private int voteNumber = 1;
public PlayerVoteEvent(VoteSite voteSite, String voteUsername, String serviceSite, boolean realVote) {
super(true);
this.player = voteUsername;
@@ -0,0 +1,58 @@
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;
import lombok.Setter;
// TODO: Auto-generated Javadoc
/**
* The Class PlayerVoteEvent.
*/
public class PlayerVoteSiteCoolDownEndEvent extends Event {
/** The Constant handlers. */
private static final HandlerList handlers = new HandlerList();
/**
* Gets the handler list.
*
* @return the handler list
*/
public static HandlerList getHandlerList() {
return handlers;
}
@Getter
@Setter
private boolean cancelled;
@Getter
@Setter
private VotingPluginUser player;
@Getter
@Setter
private VoteSite site;
public PlayerVoteSiteCoolDownEndEvent(VotingPluginUser user, VoteSite site) {
super(true);
player = user;
this.site = site;
}
/*
* (non-Javadoc)
*
* @see org.bukkit.event.Event#getHandlers()
*/
@Override
public HandlerList getHandlers() {
return handlers;
}
}
@@ -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, ALMOSTALLSITES;
@Getter
private int amount = -1;
@@ -18,7 +18,7 @@ import com.bencodez.votingplugin.signs.SignHandler;
public class BlockBreak implements Listener {
/** The plugin. */
private static VotingPluginMain plugin;
private VotingPluginMain plugin;
/**
* Instantiates a new block break.
@@ -26,7 +26,7 @@ public class BlockBreak implements Listener {
* @param plugin the plugin
*/
public BlockBreak(VotingPluginMain plugin) {
BlockBreak.plugin = plugin;
this.plugin = plugin;
}
/**
@@ -1,5 +1,7 @@
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;
@@ -8,8 +10,14 @@ import com.vexsoftware.votifier.model.VotifierEvent;
public class BungeeVotifierEvent {
public void send(VotingPluginMain plugin, PlayerVoteEvent event) {
plugin.debug("Triggering vote event");
VotifierEvent e = new VotifierEvent(
new Vote(event.getServiceSite(), event.getPlayer(), "VotingPlugin", "" + event.getTime()));
plugin.getServer().getPluginManager().callEvent(e);
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);
}
});
}
}
@@ -21,7 +21,7 @@ import com.bencodez.votingplugin.user.UserManager;
public class PlayerInteract implements Listener {
/** The plugin. */
private static VotingPluginMain plugin;
private VotingPluginMain plugin;
/**
* Instantiates a new player interact.
@@ -29,7 +29,7 @@ public class PlayerInteract implements Listener {
* @param plugin the plugin
*/
public PlayerInteract(VotingPluginMain plugin) {
PlayerInteract.plugin = plugin;
this.plugin = plugin;
}
/**
@@ -1,15 +1,14 @@
package com.bencodez.votingplugin.listeners;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.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;
@@ -20,7 +19,7 @@ import com.bencodez.votingplugin.user.VotingPluginUser;
public class PlayerJoinEvent implements Listener {
/** The plugin. */
private static VotingPluginMain plugin;
private VotingPluginMain plugin;
/**
* Instantiates a new player join event.
@@ -28,34 +27,7 @@ public class PlayerJoinEvent implements Listener {
* @param plugin the plugin
*/
public PlayerJoinEvent(VotingPluginMain plugin) {
PlayerJoinEvent.plugin = plugin;
}
/**
* On player login.
*
* @param event the event
*/
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onPlayerLogin(AdvancedCoreLoginEvent event) {
if (event.getPlayer() == null || (VotingPluginMain.plugin.getStorageType().equals(UserStorage.MYSQL)
&& VotingPluginMain.plugin.getMysql() == null)) {
return;
}
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);
}
this.plugin = plugin;
}
private void login(Player player) {
@@ -74,24 +46,46 @@ public class PlayerJoinEvent implements Listener {
}
user.loginRewards();
plugin.getPlaceholders().onUpdate(user);
if (plugin.getBungeeSettings().isUseBungeecoord()
&& plugin.getBungeeHandler().getMethod().equals(BungeeMethod.PLUGINMESSAGING)) {
plugin.getPluginMessaging().sendPluginMessage("Login", user.getPlayerName(), user.getUUID(),
plugin.getBungeeSettings().getServer());
}
}
/**
* On player login.
*
* @param event the event
*/
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onPlayerLogin(AdvancedCoreLoginEvent event) {
if (event.getPlayer() == null || !plugin.isMySQLOkay()) {
return;
}
login(event.getPlayer());
}
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onPlayerQuit(PlayerQuitEvent event) {
if (plugin.getConfigFile().isDisableAdvancedTab()) {
return;
if (plugin != null && plugin.isEnabled()) {
final java.util.UUID uuid = event.getPlayer().getUniqueId();
plugin.getLoginTimer().execute(new Runnable() {
@Override
public void run() {
VotingPluginMain.plugin.getAdvancedTab().remove(uuid);
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(uuid);
user.dontCache();
user.logoutRewards();
}
});
}
final java.util.UUID uuid = event.getPlayer().getUniqueId();
Bukkit.getScheduler().runTaskAsynchronously(plugin, new Runnable() {
@Override
public void run() {
VotingPluginMain.plugin.getAdvancedTab().remove(uuid);
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(uuid);
user.logoutRewards();
}
});
}
}
@@ -5,6 +5,7 @@ import java.time.ZoneId;
import java.util.ArrayList;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
@@ -13,6 +14,7 @@ import com.bencodez.advancedcore.api.misc.ArrayUtils;
import com.bencodez.advancedcore.api.misc.PlayerUtils;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.bungee.BungeeMethod;
import com.bencodez.votingplugin.events.PlayerPostVoteEvent;
import com.bencodez.votingplugin.events.PlayerVoteEvent;
import com.bencodez.votingplugin.objects.VoteSite;
import com.bencodez.votingplugin.user.UserManager;
@@ -24,8 +26,6 @@ import com.bencodez.votingplugin.user.VotingPluginUser;
*/
public class PlayerVoteListener implements Listener {
private static Object object = new Object();
private VotingPluginMain plugin;
/**
@@ -44,7 +44,12 @@ public class PlayerVoteListener implements Listener {
*/
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onplayerVote(PlayerVoteEvent event) {
if (!plugin.isEnabled()) {
plugin.getLogger().warning("Plugin disabled, ignoring vote");
return;
}
String playerName = event.getPlayer();
plugin.debug("Processing PlayerVoteEvent: " + playerName + "/" + event.getServiceSite());
if (!PlayerUtils.getInstance().isValidUser(playerName, plugin.getConfigFile().isAllowUnJoinedCheckServer())) {
if (!plugin.getConfigFile().isAllowUnjoined()) {
plugin.getLogger().warning("Player " + playerName
@@ -57,7 +62,7 @@ public class PlayerVoteListener implements Listener {
}
if (playerName.isEmpty()) {
plugin.getLogger().warning("Empty player name for vote");
plugin.getLogger().warning("Empty player name from vote, ignoring");
return;
}
@@ -72,6 +77,10 @@ public class PlayerVoteListener implements Listener {
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()) {
@@ -87,16 +96,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();
Player p = Bukkit.getPlayerExact(playerName);
if (p != null) {
// player online
user = UserManager.getInstance().getVotingPluginUser(p);
} else {
user = UserManager.getInstance().getVotingPluginUser(playerName);
}
}
if (voteSite.isWaitUntilVoteDelay() && !user.canVoteSite(voteSite)) {
@@ -104,11 +119,18 @@ public class PlayerVoteListener implements Listener {
return;
}
synchronized (object) {
final String uuid = user.getUUID();
// vote party
plugin.getVoteParty().vote(user, event.isRealVote(), event.isForceBungee());
// reupdate cache
user.clearCache();
user.cache();
user.updateName(true);
// vote party
plugin.getVoteParty().vote(user, event.isRealVote(), event.isForceBungee());
if (event.isBroadcast() && !plugin.getBungeeSettings().isDisableBroadcast()) {
// broadcast vote if enabled in config
if (plugin.getConfigFile().isBroadcastVotesEnabled()
&& (plugin.getBungeeSettings().isBungeeBroadcast() || !event.isBungee())) {
@@ -116,89 +138,100 @@ public class PlayerVoteListener implements Listener {
voteSite.broadcastVote(user);
}
}
}
if (plugin.getBroadcastHandler() != null) {
plugin.getBroadcastHandler().onVote(playerName);
}
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);
// update last vote time
if (event.getTime() != 0) {
user.setTime(voteSite, event.getTime());
} else {
user.setTime(voteSite);
}
// try logging to file
if (plugin.getConfigFile().isLogVotesToFile()) {
try {
VotingPluginMain.plugin.logVote(
LocalDateTime.now().atZone(ZoneId.systemDefault()).toLocalDateTime(), playerName,
voteSite.getKey());
} catch (Exception e) {
e.printStackTrace();
}
}
// check first vote rewards
plugin.getSpecialRewards().checkFirstVote(user, event.isForceBungee());
if (user.isReminded()) {
user.setReminded(false);
}
// check if player has voted on all sites in one day
if (((user.isOnline() || voteSite.isGiveOffline())
&& VotingPluginMain.plugin.getOptions().isProcessRewards()) || event.isBungee()) {
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());
plugin.debug(
"Offline vote set for " + playerName + " (" + user.getUUID() + ") on " + voteSite.getKey());
}
// add to total votes
if ((plugin.getConfigFile().isCountFakeVotes() || event.isRealVote()) && event.isAddTotals()) {
if (plugin.getConfigFile().isAddTotals()) {
user.addTotal();
user.addTotalDaily();
user.addTotalWeekly();
}
user.addPoints();
}
user.checkDayVoteStreak(event.isForceBungee());
// other rewards
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)) {
final String uuid = user.getUUID();
Bukkit.getScheduler().runTaskLaterAsynchronously(plugin, new Runnable() {
@Override
public void run() {
if (Bukkit.getOnlinePlayers().size() > 0) {
plugin.getPluginMessaging().sendPluginMessage(
PlayerUtils.getInstance().getRandomOnlinePlayer(), "VoteUpdate", uuid);
}
}
}, 40);
}
// try logging to file
if (plugin.getConfigFile().isLogVotesToFile()) {
try {
plugin.logVote(LocalDateTime.now().atZone(ZoneId.systemDefault()).toLocalDateTime(), playerName,
voteSite.getKey());
} catch (Exception e) {
e.printStackTrace();
}
}
// check first vote rewards
plugin.getSpecialRewards().checkFirstVote(user, event.isForceBungee());
plugin.getSpecialRewards().checkFirstVoteToday(user, event.isForceBungee());
if (user.isReminded() && plugin.getConfigFile().getVoteRemindingRemindOnlyOnce()) {
user.setReminded(false);
}
// check if player has voted on all sites in one day
if (((user.isOnline() || voteSite.isGiveOffline()) && plugin.getOptions().isProcessRewards())
|| event.isBungee()) {
boolean online = true;
if (event.isBungee()) {
online = event.isWasOnline();
}
user.playerVote(voteSite, online, false, event.isForceBungee());
if (event.getVoteNumber() == 1) {
user.sendVoteEffects(online);
}
if (plugin.getConfigFile().isCloseInventoryOnVote()) {
user.closeInv();
}
} else {
user.addOfflineVote(voteSite.getKey());
plugin.debug("Offline vote set for " + playerName + " (" + user.getUUID() + ") on " + voteSite.getKey());
}
// add to total votes
if ((plugin.getConfigFile().isCountFakeVotes() || event.isRealVote()) && event.isAddTotals()) {
if (plugin.getConfigFile().isAddTotals()) {
user.addTotal();
user.addTotalDaily();
user.addTotalWeekly();
}
user.addPoints();
}
user.checkDayVoteStreak(event.isForceBungee());
// other rewards
plugin.getSpecialRewards().checkAllSites(user, event.isForceBungee());
plugin.getSpecialRewards().checkAlmostAllSites(user, event.isForceBungee());
plugin.getSpecialRewards().checkCumualativeVotes(user, event.getBungeeTextTotals(), event.isForceBungee());
plugin.getSpecialRewards().checkMilestone(user, event.getBungeeTextTotals(), event.isForceBungee());
plugin.getCoolDownCheck().vote(user, voteSite);
if (plugin.getBungeeSettings().isUseBungeecoord()) {
if (plugin.getBungeeHandler().getMethod().equals(BungeeMethod.MYSQL)) {
Bukkit.getScheduler().runTaskLaterAsynchronously(plugin, new Runnable() {
@Override
public void run() {
if (Bukkit.getOnlinePlayers().size() > 0) {
plugin.getPluginMessaging().sendPluginMessage("VoteUpdate", uuid);
}
}
}, 40);
}
}
PlayerPostVoteEvent postVoteEvent = new PlayerPostVoteEvent(voteSite, user, event.isRealVote(),
event.isForceBungee());
plugin.getServer().getPluginManager().callEvent(postVoteEvent);
if (!user.isOnline()) {
user.clearCache();
}
plugin.setUpdate(true);
plugin.extraDebug("Finished vote processing: " + playerName + "/" + uuid);
}
}
@@ -16,7 +16,7 @@ import com.bencodez.votingplugin.VotingPluginMain;
public class SignChange implements Listener {
/** The plugin. */
private static VotingPluginMain plugin;
private VotingPluginMain plugin;
/**
* Instantiates a new sign change.
@@ -24,7 +24,7 @@ public class SignChange implements Listener {
* @param plugin the plugin
*/
public SignChange(VotingPluginMain plugin) {
SignChange.plugin = plugin;
this.plugin = plugin;
}
/**
@@ -2,7 +2,6 @@ package com.bencodez.votingplugin.listeners;
import java.util.ArrayList;
import org.bukkit.Bukkit;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
@@ -41,20 +40,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
public void run() {
plugin.getServerData().addServiceSite(voteSite);
}
});
if (voteUsername.length() == 0) {
plugin.getLogger().warning("No name from vote on " + voteSite);
@@ -68,51 +64,66 @@ public class VotiferEvent implements Listener {
plugin.debug("VoteSite: " + voteSite);
plugin.debug("IP: " + IP);
Bukkit.getScheduler().runTaskAsynchronously(plugin, new Runnable() {
plugin.getVoteTimer().submit(new Runnable() {
@Override
public void run() {
try {
plugin.getServerData().addServiceSite(voteSite);
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, please check: https://github.com/BenCodez/VotingPlugin/wiki/Bungeecord-Setups");
return;
}
String voteSiteNameStr = plugin.getVoteSiteName(false, voteSite);
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");
return;
}
String voteSiteName = plugin.getVoteSiteName(voteSite);
ArrayList<String> sites = plugin.getConfigVoteSites().getVoteSitesNames();
boolean createSite = false;
if (sites != null) {
if (!sites.contains(voteSiteName)) {
ArrayList<String> sites = plugin.getConfigVoteSites().getVoteSitesNames(false);
boolean createSite = false;
if (sites != null) {
if (!ArrayUtils.getInstance().containsIgnoreCase(sites, voteSiteNameStr)) {
createSite = true;
}
} else {
createSite = true;
}
} else {
createSite = true;
}
if (plugin.getConfigFile().isAutoCreateVoteSites() && createSite) {
plugin.getLogger().warning("VoteSite with service site '" + voteSiteName
+ "' does not exist, attempting to generaterate...");
plugin.getConfigVoteSites().generateVoteSite(voteSiteName);
plugin.getLogger()
.info("Current known service sites: " + ArrayUtils.getInstance().makeStringList(plugin.getServerData().getServiceSites()));
}
if (plugin.getConfigFile().isAutoCreateVoteSites() && createSite) {
plugin.getLogger().warning("VoteSite with service site '" + voteSiteNameStr
+ "' does not exist, attempting to generate...");
plugin.getConfigVoteSites().generateVoteSite(voteSiteNameStr);
PlayerVoteEvent voteEvent = new PlayerVoteEvent(plugin.getVoteSite(voteSiteName), voteUsername,
voteSite, true);
plugin.getServer().getPluginManager().callEvent(voteEvent);
plugin.getLogger().info("Current known service sites: "
+ ArrayUtils.getInstance().makeStringList(plugin.getServerData().getServiceSites()));
}
if (voteEvent.isCancelled()) {
plugin.debug("Vote cancelled");
return;
if (plugin.getTimeChecker().isActiveProcessing()
&& plugin.getConfigFile().isQueueVotesDuringTimeChange()) {
// time change in progress
plugin.debug("Adding vote to time queue " + voteUsername + "/" + voteSite);
plugin.getTimeQueueHandler().addVote(voteUsername, voteSite);
return;
}
String voteSiteName = plugin.getVoteSiteName(true, voteSite);
PlayerVoteEvent voteEvent = new PlayerVoteEvent(plugin.getVoteSite(voteSiteName, true),
voteUsername, voteSite, true);
plugin.getServer().getPluginManager().callEvent(voteEvent);
if (voteEvent.isCancelled()) {
plugin.debug("Vote cancelled");
return;
}
} catch (Exception e) {
plugin.getLogger().severe("Error occured during vote processing");
e.printStackTrace();
}
}
});
}
}
@@ -14,7 +14,7 @@ import com.bencodez.votingplugin.VotingPluginMain;
public class VotingPluginUpdateEvent implements Listener {
/** The plugin. */
private static VotingPluginMain plugin;
private VotingPluginMain plugin;
/**
* Instantiates a new advanced core update event.
@@ -22,7 +22,7 @@ public class VotingPluginUpdateEvent implements Listener {
* @param plugin the plugin
*/
public VotingPluginUpdateEvent(VotingPluginMain plugin) {
VotingPluginUpdateEvent.plugin = plugin;
this.plugin = plugin;
}
/**
@@ -13,9 +13,7 @@ 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;
import com.bencodez.votingplugin.bungee.BungeeMethod;
import com.bencodez.votingplugin.user.UserManager;
@@ -36,13 +34,17 @@ public class VoteSite {
@Setter
private boolean enabled;
@Getter
@Setter
private boolean giveOffline;
@Getter
@Setter
private boolean hidden;
@Getter
@Setter
private boolean giveOffline;
private boolean ignoreCanVote;
@Setter
private ConfigurationSection item;
@@ -83,10 +85,6 @@ public class VoteSite {
@Getter
@Setter
private boolean waitUntilVoteDelay;
@Getter
@Setter
private boolean ignoreCanVote;
public VoteSite(VotingPluginMain plugin, String siteName) {
this.plugin = plugin;
@@ -109,6 +107,11 @@ public class VoteSite {
return;
}
if (!user.isVanished()) {
String playerName = user.getPlayerName();
if (plugin.getConfigFile().getVotingBroadcastBlacklist().contains(playerName)) {
plugin.getLogger().info("Not broadcasting for " + playerName + ", in blacklist");
return;
}
if (checkBungee && plugin.getBungeeSettings().isBungeeBroadcast()
&& plugin.getBungeeSettings().isUseBungeecoord()) {
if (plugin.getBungeeHandler().getMethod().equals(BungeeMethod.SOCKETS)) {
@@ -119,17 +122,11 @@ 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);
}
}
} else {
String playerName = user.getPlayerName();
if (plugin.getConfigFile().getVotingBroadcastBlacklist().contains(playerName)) {
plugin.getLogger().info("Not broadcasting for " + playerName + ", in blacklist");
return;
}
String bc = StringParser.getInstance().colorize(plugin.getConfigFile().getFormatBroadCastMsg());
HashMap<String, String> placeholders = new HashMap<String, String>();
placeholders.put("player", playerName);
@@ -175,7 +172,8 @@ public class VoteSite {
}
public String getVoteURL(boolean json) {
if (!plugin.getConfigFile().isFormatCommandsVoteForceLinks() || !json) {
if (!plugin.getConfigFile().isFormatCommandsVoteForceLinks() || !json
|| StringParser.getInstance().containsJson(voteURL)) {
return voteURL;
} else {
if (!voteURL.startsWith("http")) {
@@ -211,7 +209,7 @@ public class VoteSite {
}
public boolean hasRewards() {
return RewardHandler.getInstance().hasRewards(plugin.getConfigVoteSites().getData(),
return plugin.getRewardHandler().hasRewards(plugin.getConfigVoteSites().getData(),
plugin.getConfigVoteSites().getRewardsPath(key));
}
@@ -242,4 +240,19 @@ public class VoteSite {
return ArrayUtils.getInstance().containsIgnoreCase(plugin.getServerData().getServiceSites(), getServiceSite());
}
public String loadingDebug() {
String str = "Loading votesite key: " + key;
str += ", Displayname: " + displayName;
str += ", VoteDelay: " + getVoteDelay();
str += ", VoteDelayMin: " + getVoteDelayMin();
str += ", VoteDelayDaily: " + isVoteDelayDaily();
str += ", IsWaitUntilVoteDelay: " + isWaitUntilVoteDelay();
str += ", ServiceSite: " + getServiceSite();
str += ", TimeOffSet:" + getTimeOffSet();
str += ", Url: " + getVoteURL();
str += ", IgnoreCanVote: " + isIgnoreCanVote();
str += ", Hidden: " + isHidden();
return str;
}
}
@@ -2,6 +2,7 @@ package com.bencodez.votingplugin.placeholders;
import org.bukkit.Bukkit;
import com.bencodez.advancedcore.api.placeholder.NonPlayerPlaceHolder;
import com.bencodez.advancedcore.api.placeholder.PlaceHolder;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.user.UserManager;
@@ -46,7 +47,7 @@ public class MVdWPlaceholders {
&& user.hasPrimaryAccount()) {
user = UserManager.getInstance().getVotingPluginUser(user.getPrimaryAccount());
}
return place.placeholderRequest(event.getOfflinePlayer(), user,
return place.placeholderRequest(user,
event.getPlaceholder().substring("VotingPlugin_".length()));
}
@@ -55,7 +56,7 @@ public class MVdWPlaceholders {
}
for (final PlaceHolder<VotingPluginUser> place : plugin.getPlaceholders().getNonPlayerPlaceholders()) {
for (final NonPlayerPlaceHolder<VotingPluginUser> place : plugin.getPlaceholders().getNonPlayerPlaceholders()) {
String str = place.getIdentifier();
if (!str.endsWith("_")) {
PlaceholderAPI.registerPlaceholder(VotingPluginMain.plugin, "VotingPlugin_" + str,
@@ -63,7 +64,7 @@ public class MVdWPlaceholders {
@Override
public String onPlaceholderReplace(PlaceholderReplaceEvent event) {
return place.placeholderRequest(event.getOfflinePlayer(), null,
return place.placeholderRequest(
event.getPlaceholder().substring("VotingPlugin_".length()));
}
@@ -1,20 +1,30 @@
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.HashSet;
import java.util.Locale;
import java.util.Map.Entry;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.messages.StringParser;
import com.bencodez.advancedcore.api.placeholder.NonPlayerPlaceHolder;
import com.bencodez.advancedcore.api.placeholder.PlaceHolder;
import com.bencodez.advancedcore.api.user.AdvancedCoreUser;
import com.bencodez.advancedcore.api.user.UserDataChanged;
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;
@@ -27,7 +37,7 @@ import lombok.Getter;
public class PlaceHolders {
@Getter
private ArrayList<PlaceHolder<VotingPluginUser>> nonPlayerPlaceholders = new ArrayList<PlaceHolder<VotingPluginUser>>();
private ArrayList<NonPlayerPlaceHolder<VotingPluginUser>> nonPlayerPlaceholders = new ArrayList<NonPlayerPlaceHolder<VotingPluginUser>>();
@Getter
private ArrayList<PlaceHolder<VotingPluginUser>> placeholders = new ArrayList<PlaceHolder<VotingPluginUser>>();
@@ -36,49 +46,138 @@ public class PlaceHolders {
public PlaceHolders(VotingPluginMain plugin) {
this.plugin = plugin;
cacheLevel = plugin.getConfigFile().getPlaceholderCacheLevel();
}
public void reload() {
cacheLevel = plugin.getConfigFile().getPlaceholderCacheLevel();
}
private ArrayList<String> cachedPlaceholders = new ArrayList<String>();
private ConcurrentLinkedQueue<String> placeholdersToSetCacheOn = new ConcurrentLinkedQueue<String>();
@Getter
private PlaceholderCacheLevel cacheLevel;
public String getPlaceHolder(OfflinePlayer p, String identifier) {
if (plugin.getConfigFile().isUseJavascriptPlaceholders()) {
return getPlaceHolder(p, identifier, true);
}
public String getPlaceHolder(OfflinePlayer p, String identifier1, boolean javascript) {
boolean forceProcess = false;
boolean useCache = true;
String identifier = identifier1.toLowerCase();
if (identifier.endsWith("_process")) {
forceProcess = true;
identifier = identifier.replaceAll("_process", "");
}
if (identifier.endsWith("_nocache")) {
useCache = false;
identifier = identifier.replaceAll("_nocache", "");
}
if (getCacheLevel().equals(PlaceholderCacheLevel.NONE)) {
useCache = false;
}
if (plugin.getConfigFile().isUseJavascriptPlaceholders() && javascript && p != null) {
identifier = StringParser.getInstance().replaceJavascript(p, identifier);
}
for (PlaceHolder<VotingPluginUser> placeholder : nonPlayerPlaceholders) {
if (placeholder.matches(identifier)) {
return placeholder.placeholderRequest(p, null, identifier);
if (!identifier.endsWith("Position")) {
for (NonPlayerPlaceHolder<VotingPluginUser> placeholder : nonPlayerPlaceholders) {
if (placeholder.matches(identifier)) {
String str = placeholder.placeholderRequest(identifier);
if (str != null) {
return str;
}
}
}
}
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(p);
if (Bukkit.isPrimaryThread()) {
user.setWaitForCache(false);
if (p == null) {
return "no player";
}
if (plugin.getConfigFile().isUsePrimaryAccountForPlaceholders() && user.hasPrimaryAccount()) {
user = UserManager.getInstance().getVotingPluginUser(user.getPrimaryAccount());
if (Bukkit.isPrimaryThread()) {
user.setWaitForCache(false);
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(p);
if (useCache) {
if (!cachedPlaceholders.contains(identifier)) {
// not cached placeholder
if (!forceProcess) {
for (PlaceHolder<VotingPluginUser> placeholder : placeholders) {
if (placeholder.matches(identifier)) {
if (getCacheLevel().shouldCache()) {
if (!placeholdersToSetCacheOn.contains(identifier)) {
placeholdersToSetCacheOn.add(identifier);
schedulePlaceholderCheck(user);
}
}
return "..";
}
}
return "Not a valid placeholder";
}
}
}
if (plugin.getConfigFile().isUsePrimaryAccountForPlaceholders()) {
if (user.hasPrimaryAccount()) {
user = UserManager.getInstance().getVotingPluginUser(user.getPrimaryAccount());
}
}
for (PlaceHolder<VotingPluginUser> placeholder : placeholders) {
try {
if (placeholder.matches(identifier)) {
return placeholder.placeholderRequest(p, user, identifier);
if (useCache) {
if (placeholder.isUsesCache() && placeholder.isCached(identifier)) {
ConcurrentHashMap<UUID, String> cache = placeholder.getCache().get(identifier);
if (cache.containsKey(p.getUniqueId())) {
return cache.get(p.getUniqueId());
} else if (!forceProcess) {
schedulePlaceholderCheck(user);
return "...";
}
}
if (forceProcess) {
if (getCacheLevel().shouldCache()) {
if (!placeholdersToSetCacheOn.contains(identifier)
&& !cachedPlaceholders.contains(identifier)) {
placeholdersToSetCacheOn.add(identifier);
schedulePlaceholderCheck(user);
}
}
return placeholder.placeholderRequest(user, identifier);
} else {
if (getCacheLevel().shouldCache()) {
if (!placeholdersToSetCacheOn.contains(identifier)
&& !cachedPlaceholders.contains(identifier)) {
placeholdersToSetCacheOn.add(identifier);
schedulePlaceholderCheck(user);
}
}
return ".";
}
} else {
return placeholder.placeholderRequest(user, identifier);
}
}
} catch (Exception e) {
plugin.debug(e);
return "...";
return "Error";
}
}
return "Not a valid placeholder";
}
public String getPlaceHolder(Player p, String identifier) {
if (plugin.getConfigFile().isUseJavascriptPlaceholders()) {
identifier = StringParser.getInstance().replaceJavascript(p, identifier);
}
return getPlaceHolder((OfflinePlayer) p, identifier);
return getPlaceHolder(p, identifier, false);
}
public void load() {
@@ -89,54 +188,54 @@ public class PlaceHolders {
placeholders.add(new PlaceHolder<VotingPluginUser>("total") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
return Integer.toString(user.getTotal(TopVoter.Monthly));
}
}.withDescription("Month total"));
}.withDescription("Month total").updateDataKey("MonthTotal"));
placeholders.add(new PlaceHolder<VotingPluginUser>("alltimetotal") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
return Integer.toString(user.getTotal(TopVoter.AllTime));
}
}.withDescription("Alltime total"));
}.withDescription("Alltime total").updateDataKey("AllTimeTotal"));
placeholders.add(new PlaceHolder<VotingPluginUser>("lastmonthtotal") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
return Integer.toString(user.getLastMonthTotal());
}
}.withDescription("Last month total"));
}.withDescription("Last month total").updateDataKey("LastMonthTotal"));
// end of older placeholders
placeholders.add(new PlaceHolder<VotingPluginUser>("DisableBroadcast") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
return "" + user.getDisableBroadcast();
}
}.withDescription("Returns true/false if user has broadcast disabled"));
}.withDescription("Returns true/false if user has broadcast disabled").updateDataKey("DisableBroadcast"));
placeholders.add(new PlaceHolder<VotingPluginUser>("MilestoneCount") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
return "" + user.getMilestoneCount();
}
}.withDescription("User milestonecount"));
}.withDescription("User milestonecount").updateDataKey("MilestoneCount"));
for (final String identifier : plugin.getGui().getChestShopIdentifiers()) {
if (plugin.getGui().getChestShopIdentifierLimit(identifier) > 0) {
placeholders.add(new PlaceHolder<VotingPluginUser>("VoteShopLimit_" + identifier) {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String ident) {
public String placeholderRequest(VotingPluginUser user, String ident) {
return "" + user.getVoteShopIdentifierLimit(identifier);
}
}.withDescription("User voteshop limit for " + identifier));
}.withDescription("User voteshop limit for " + identifier).updateDataKey("VoteShopLimit" + identifier));
}
}
@@ -144,113 +243,121 @@ public class PlaceHolders {
placeholders.add(new PlaceHolder<VotingPluginUser>("Total_" + top.toString()) {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
return Integer.toString(user.getTotal(top));
}
}.withDescription("User total for " + top.getName()));
}.withDescription("User total for " + top.getName()).updateDataKey(top.getColumnName()));
}
placeholders.add(new PlaceHolder<VotingPluginUser>("BestDailyTotal") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
return Integer.toString(user.getHighestDailyTotal());
}
}.withDescription("Best daily total"));
}.withDescription("Best daily total").updateDataKey("HighestDailyTotal"));
placeholders.add(new PlaceHolder<VotingPluginUser>("BestWeeklyTotal") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
return Integer.toString(user.getHighestWeeklyTotal());
}
}.withDescription("Best weekly total"));
}.withDescription("Best weekly total").updateDataKey("HighestWeeklyTotal"));
placeholders.add(new PlaceHolder<VotingPluginUser>("BestMonthlyTotal") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
return Integer.toString(user.getHighestMonthlyTotal());
}
}.withDescription("Best monthly total"));
}.withDescription("Best monthly total").updateDataKey("HighestMonthlyTotal"));
placeholders.add(new PlaceHolder<VotingPluginUser>("DailyVoteStreak") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
return Integer.toString(user.getDayVoteStreak());
}
}.withDescription("Current daily votestreak"));
}.withDescription("Current daily votestreak").updateDataKey("DayVoteStreak"));
placeholders.add(new PlaceHolder<VotingPluginUser>("WeeklyVoteStreak") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
return Integer.toString(user.getWeekVoteStreak());
}
}.withDescription("Current weekly votestreak"));
}.withDescription("Current weekly votestreak").updateDataKey("WeekVoteStreak"));
placeholders.add(new PlaceHolder<VotingPluginUser>("MonthVoteStreak") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
return Integer.toString(user.getMonthVoteStreak());
}
}.withDescription("Current month votestreak"));
}.withDescription("Current month votestreak").updateDataKey("MonthVoteStreak"));
placeholders.add(new PlaceHolder<VotingPluginUser>("BestDailyVoteStreak") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
return Integer.toString(user.getBestDayVoteStreak());
}
}.withDescription("Best daily votestreak"));
}.withDescription("Best daily votestreak").updateDataKey("BestDayVoteStreak"));
placeholders.add(new PlaceHolder<VotingPluginUser>("BestWeeklyVoteStreak") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
return Integer.toString(user.getBestWeekVoteStreak());
}
}.withDescription("Best weekly votestreak"));
}.withDescription("Best weekly votestreak").updateDataKey("BestWeekVoteStreak"));
placeholders.add(new PlaceHolder<VotingPluginUser>("BestMonthVoteStreak") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
return Integer.toString(user.getBestMonthVoteStreak());
}
}.withDescription("Best month votestreak"));
}.withDescription("Best month votestreak").updateDataKey("BestMonthVoteStreak"));
placeholders.add(new PlaceHolder<VotingPluginUser>("Points") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
return Integer.toString(user.getPoints());
}
}.withDescription("User points"));
}.withDescription("User points").updateDataKey("Points"));
placeholders.add(new PlaceHolder<VotingPluginUser>("Points_Format") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
NumberFormat numberFormat = NumberFormat.getNumberInstance(Locale.US);
return numberFormat.format(user.getPoints());
}
}.withDescription("User points"));
}.withDescription("User points").updateDataKey("Points"));
placeholders.add(new PlaceHolder<VotingPluginUser>("CanVote") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
return Boolean.toString(user.canVoteAll());
}
}.withDescription("Return true/false if player can vote on all sites"));
}.withDescription("Return true/false if player can vote on all sites").updateDataKey("LastVotes"));
placeholders.add(new PlaceHolder<VotingPluginUser>("CanVoteSites") {
@Override
public String placeholderRequest(VotingPluginUser user, String identifier) {
return "" + user.getSitesNotVotedOn();
}
}.withDescription("Return number of votesites available").updateDataKey("LastVotes"));
placeholders.add(new PlaceHolder<VotingPluginUser>("Next_AnySite") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
if (user.canVoteAny()) {
return plugin.getConfigFile().getFormatCommandsVoteNextInfoCanVote();
}
@@ -274,39 +381,40 @@ public class PlaceHolders {
return "Error";
}
}.withDescription("How long until user can vote on anysite"));
}.withDescription("How long until user can vote on anysite").updateDataKey("LastVotes"));
for (final VoteSite voteSite : plugin.getVoteSites()) {
placeholders.add(new PlaceHolder<VotingPluginUser>("Next_" + voteSite.getKey()) {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
return user.voteCommandNextInfo(voteSite);
}
}.withDescription("How long until user can vote on " + voteSite.getKey()));
}.withDescription("How long until user can vote on " + voteSite.getKey()).updateDataKey("LastVotes"));
placeholders.add(new PlaceHolder<VotingPluginUser>("Last_" + voteSite.getKey()) {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
return user.voteCommandLastDuration(voteSite);
}
}.withDescription("How long ago user voted on " + voteSite.getKey()));
}.withDescription("How long ago user voted on " + voteSite.getKey()).updateDataKey("LastVotes"));
placeholders.add(new PlaceHolder<VotingPluginUser>("CanVote_" + voteSite.getKey()) {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
return "" + user.canVoteSite(voteSite);
}
}.withDescription("Whether or not player can vote on " + voteSite.getKey()));
}.withDescription("Whether or not player can vote on " + voteSite.getKey()).updateDataKey("LastVotes"));
}
placeholders.add(new PlaceHolder<VotingPluginUser>("Top_All_Position") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(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())) {
UUID toMatch = UUID.fromString(user.getUUID());
for (Entry<TopVoterPlayer, Integer> entry : plugin.getTopVoter(TopVoter.AllTime).entrySet()) {
if (entry.getKey().getUuid().equals(toMatch)) {
return "" + num;
}
num++;
@@ -315,15 +423,15 @@ public class PlaceHolders {
}
}.withDescription("Get user top voter position"));
placeholders.add(new PlaceHolder<VotingPluginUser>("Top_AllVotes_") {
nonPlayerPlaceholders.add(new NonPlayerPlaceHolder<VotingPluginUser>("Top_AllVotes_") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(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++;
}
@@ -331,13 +439,16 @@ public class PlaceHolders {
}
}.useStartsWith().withDescription("Get user votes at position in top voter"));
placeholders.add(new PlaceHolder<VotingPluginUser>("Top_All_") {
nonPlayerPlaceholders.add(new NonPlayerPlaceHolder<VotingPluginUser>("Top_All_") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(String identifier) {
if (!StringParser.getInstance().isInt(identifier.split("_")[2])) {
return null;
}
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();
}
@@ -350,10 +461,11 @@ public class PlaceHolders {
placeholders.add(new PlaceHolder<VotingPluginUser>("Top_Month_Position") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(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())) {
UUID toMatch = UUID.fromString(user.getUUID());
for (Entry<TopVoterPlayer, Integer> entry : plugin.getTopVoter(TopVoter.Monthly).entrySet()) {
if (entry.getKey().getUuid().equals(toMatch)) {
return "" + num;
}
num++;
@@ -362,13 +474,16 @@ public class PlaceHolders {
}
}.withDescription("Get user top voter position"));
placeholders.add(new PlaceHolder<VotingPluginUser>("Top_Month_") {
nonPlayerPlaceholders.add(new NonPlayerPlaceHolder<VotingPluginUser>("Top_Month_") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(String identifier) {
if (!StringParser.getInstance().isInt(identifier.split("_")[2])) {
return null;
}
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();
}
@@ -378,15 +493,15 @@ public class PlaceHolders {
}
}.useStartsWith().withDescription("Get user at position in top voter"));
placeholders.add(new PlaceHolder<VotingPluginUser>("Top_MonthVotes_") {
nonPlayerPlaceholders.add(new NonPlayerPlaceHolder<VotingPluginUser>("Top_MonthVotes_") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(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++;
}
@@ -397,10 +512,11 @@ public class PlaceHolders {
placeholders.add(new PlaceHolder<VotingPluginUser>("Top_Week_Position") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(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())) {
UUID toMatch = UUID.fromString(user.getUUID());
for (Entry<TopVoterPlayer, Integer> entry : plugin.getTopVoter(TopVoter.Weekly).entrySet()) {
if (entry.getKey().getUuid().equals(toMatch)) {
return "" + num;
}
num++;
@@ -409,13 +525,16 @@ public class PlaceHolders {
}
}.withDescription("Get user top voter position"));
placeholders.add(new PlaceHolder<VotingPluginUser>("Top_Week_") {
nonPlayerPlaceholders.add(new NonPlayerPlaceHolder<VotingPluginUser>("Top_Week_") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(String identifier) {
if (!StringParser.getInstance().isInt(identifier.split("_")[2])) {
return null;
}
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();
}
@@ -425,15 +544,15 @@ public class PlaceHolders {
}
}.useStartsWith().withDescription("Get user at postion in top voter"));
placeholders.add(new PlaceHolder<VotingPluginUser>("Top_WeekVotes_") {
nonPlayerPlaceholders.add(new NonPlayerPlaceHolder<VotingPluginUser>("Top_WeekVotes_") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(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++;
}
@@ -444,10 +563,11 @@ public class PlaceHolders {
placeholders.add(new PlaceHolder<VotingPluginUser>("Top_Daily_Position") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(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())) {
UUID toMatch = UUID.fromString(user.getUUID());
for (Entry<TopVoterPlayer, Integer> entry : plugin.getTopVoter(TopVoter.Daily).entrySet()) {
if (entry.getKey().getUuid().equals(toMatch)) {
return "" + num;
}
num++;
@@ -456,13 +576,16 @@ public class PlaceHolders {
}
}.withDescription("Get user top voter position"));
placeholders.add(new PlaceHolder<VotingPluginUser>("Top_Daily_") {
nonPlayerPlaceholders.add(new NonPlayerPlaceHolder<VotingPluginUser>("Top_Daily_") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(String identifier) {
if (!StringParser.getInstance().isInt(identifier.split("_")[2])) {
return null;
}
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();
}
@@ -475,20 +598,20 @@ public class PlaceHolders {
placeholders.add(new PlaceHolder<VotingPluginUser>("VotePartyContributedVotes") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(VotingPluginUser user, String identifier) {
return "" + user.getVotePartyVotes();
}
}.useStartsWith().withDescription("See vote party placeholders contributed"));
}.useStartsWith().withDescription("See vote party placeholders contributed").updateDataKey("VotePartyVotes"));
placeholders.add(new PlaceHolder<VotingPluginUser>("Top_DailyVotes_") {
nonPlayerPlaceholders.add(new NonPlayerPlaceHolder<VotingPluginUser>("Top_DailyVotes_") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(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++;
}
@@ -498,34 +621,68 @@ public class PlaceHolders {
// non players
nonPlayerPlaceholders.add(new PlaceHolder<VotingPluginUser>("VotePartyVotesCurrent") {
nonPlayerPlaceholders.add(new NonPlayerPlaceHolder<VotingPluginUser>("VotePartyVotesCurrent") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(String identifier) {
return Integer.toString(plugin.getVoteParty().getTotalVotes());
}
}.withDescription("Current amount of voteparty votes"));
nonPlayerPlaceholders.add(new PlaceHolder<VotingPluginUser>("VotePartyVotesNeeded") {
nonPlayerPlaceholders.add(new NonPlayerPlaceHolder<VotingPluginUser>("VotePartyVotesNeeded") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(String identifier) {
return Integer.toString(plugin.getVoteParty().getNeededVotes());
}
}.withDescription("Voteparty votes needed"));
nonPlayerPlaceholders.add(new PlaceHolder<VotingPluginUser>("VotePartyVotesRequired") {
nonPlayerPlaceholders.add(new NonPlayerPlaceHolder<VotingPluginUser>("VotePartyVotesRequired") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(String identifier) {
return Integer.toString(plugin.getVoteParty().getVotesRequired());
}
}.withDescription("Amount of votes needed for voteparty"));
nonPlayerPlaceholders.add(new PlaceHolder<VotingPluginUser>("GlobalMonthTotal") {
nonPlayerPlaceholders.add(new NonPlayerPlaceHolder<VotingPluginUser>("BungeeVotePartyVotesCurrent") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(String identifier) {
if (plugin.getBungeeHandler() != null) {
return Integer.toString(plugin.getBungeeHandler().getBungeeVotePartyCurrent());
}
return "" + 0;
}
}.withDescription("Current amount of bungee voteparty votes"));
nonPlayerPlaceholders.add(new NonPlayerPlaceHolder<VotingPluginUser>("BungeeVotePartyVotesNeeded") {
@Override
public String placeholderRequest(String identifier) {
if (plugin.getBungeeHandler() != null) {
return Integer.toString(plugin.getBungeeHandler().getBungeeVotePartyRequired()
- plugin.getBungeeHandler().getBungeeVotePartyCurrent());
}
return "" + 0;
}
}.withDescription("Voteparty bungee votes needed"));
nonPlayerPlaceholders.add(new NonPlayerPlaceHolder<VotingPluginUser>("BungeeVotePartyVotesRequired") {
@Override
public String placeholderRequest(String identifier) {
if (plugin.getBungeeHandler() != null) {
return Integer.toString(plugin.getBungeeHandler().getBungeeVotePartyRequired());
}
return "" + 0;
}
}.withDescription("Amount of votes needed for bungee voteparty"));
nonPlayerPlaceholders.add(new NonPlayerPlaceHolder<VotingPluginUser>("GlobalMonthTotal") {
@Override
public String placeholderRequest(String identifier) {
int total = 0;
for (int num : VotingPluginMain.plugin.getTopVoter(TopVoter.Monthly).values()) {
total += num;
@@ -534,10 +691,10 @@ public class PlaceHolders {
}
}.withDescription("Global month total"));
nonPlayerPlaceholders.add(new PlaceHolder<VotingPluginUser>("GlobalAllTimeTotal") {
nonPlayerPlaceholders.add(new NonPlayerPlaceHolder<VotingPluginUser>("GlobalAllTimeTotal") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(String identifier) {
int total = 0;
for (int num : VotingPluginMain.plugin.getTopVoter(TopVoter.AllTime).values()) {
total += num;
@@ -546,10 +703,10 @@ public class PlaceHolders {
}
}.withDescription("Global alltime total"));
nonPlayerPlaceholders.add(new PlaceHolder<VotingPluginUser>("GlobalWeeklyTotal") {
nonPlayerPlaceholders.add(new NonPlayerPlaceHolder<VotingPluginUser>("GlobalWeeklyTotal") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(String identifier) {
int total = 0;
for (int num : VotingPluginMain.plugin.getTopVoter(TopVoter.Weekly).values()) {
total += num;
@@ -558,10 +715,10 @@ public class PlaceHolders {
}
}.withDescription("Global weekly total"));
nonPlayerPlaceholders.add(new PlaceHolder<VotingPluginUser>("GlobalDailyTotal") {
nonPlayerPlaceholders.add(new NonPlayerPlaceHolder<VotingPluginUser>("GlobalDailyTotal") {
@Override
public String placeholderRequest(OfflinePlayer p, VotingPluginUser user, String identifier) {
public String placeholderRequest(String identifier) {
int total = 0;
for (int num : VotingPluginMain.plugin.getTopVoter(TopVoter.Daily).values()) {
total += num;
@@ -569,5 +726,189 @@ public class PlaceHolders {
return Integer.toString(total);
}
}.withDescription("Global daily total"));
nonPlayerPlaceholders.add(new NonPlayerPlaceHolder<VotingPluginUser>("TimeUntilDayReset") {
@Override
public String placeholderRequest(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"));
Set<String> placeholdersSet = new HashSet<String>();
placeholdersSet.addAll(plugin.getConfigFile().getCachedPlaceholders());
if (getCacheLevel().equals(PlaceholderCacheLevel.AUTO)) {
placeholdersSet.addAll(plugin.getServerData().getAutoCachedPlaceholder());
}
for (String toCache : placeholdersSet) {
if (toCache.startsWith("votingplugin")) {
toCache = toCache.substring("votingplugin_".length());
}
for (NonPlayerPlaceHolder<VotingPluginUser> placeholder : nonPlayerPlaceholders) {
if (placeholder.matches(toCache)) {
placeholder.setUseCache(true, toCache);
cachedPlaceholders.add(toCache);
plugin.extraDebug("Caching placeholder " + toCache);
}
}
for (PlaceHolder<VotingPluginUser> placeholder : placeholders) {
if (placeholder.matches(toCache)) {
placeholder.setUseCache(true, toCache);
cachedPlaceholders.add(toCache);
plugin.extraDebug("Caching placeholder " + toCache);
}
}
}
plugin.getUserManager().getUserDataChange().add(new UserDataChanged() {
@Override
public void onChange(AdvancedCoreUser user, String... keys) {
VotingPluginUser vpUser = UserManager.getInstance().getVotingPluginUser(user);
if (!vpUser.isCached()) {
vpUser.dontCache();
}
for (PlaceHolder<VotingPluginUser> placeholder : placeholders) {
if (placeholder.isUsesCache()) {
for (String key : keys) {
if (placeholder.getUpdateDataKey().equalsIgnoreCase(key)) {
for (String ident : placeholder.getCache().keySet()) {
String value = placeholder.placeholderRequest(vpUser, ident);
placeholder.getCache().get(ident).put(vpUser.getJavaUUID(), value);
plugin.devDebug("Updated placeholder cache for " + vpUser.getUUID() + " on " + key
+ " with " + value);
}
}
}
}
}
}
});
}
public void onVotePartyUpdate() {
for (NonPlayerPlaceHolder<VotingPluginUser> placeholder : nonPlayerPlaceholders) {
if (placeholder.isUsesCache()) {
if (placeholder.getIdentifier().startsWith("VoteParty")) {
for (String ident : placeholder.getCache().keySet()) {
placeholder.getCache().put(ident, placeholder.placeholderRequest(ident));
}
}
}
}
}
public void onBungeeVotePartyUpdate() {
for (NonPlayerPlaceHolder<VotingPluginUser> placeholder : nonPlayerPlaceholders) {
if (placeholder.isUsesCache()) {
if (placeholder.getIdentifier().startsWith("BungeeVoteParty")) {
for (String ident : placeholder.getCache().keySet()) {
placeholder.getCache().put(ident, placeholder.placeholderRequest(ident));
}
}
}
}
}
public void onUpdate(VotingPluginUser user) {
for (PlaceHolder<VotingPluginUser> placeholder : placeholders) {
if (placeholder.isUsesCache()) {
for (String ident : placeholder.getCache().keySet()) {
placeholder.getCache().get(ident).put(user.getJavaUUID(),
placeholder.placeholderRequest(user, ident));
}
}
}
}
public void checkNonCachedPlaceholders() {
while (!placeholdersToSetCacheOn.isEmpty()) {
String toCache = placeholdersToSetCacheOn.poll().toLowerCase();
if (toCache.startsWith("votingplugin")) {
toCache = toCache.substring("votingplugin_".length());
}
for (NonPlayerPlaceHolder<VotingPluginUser> placeholder : nonPlayerPlaceholders) {
if (placeholder.matches(toCache)) {
placeholder.setUseCache(true, toCache);
cachedPlaceholders.add(toCache);
plugin.getServerData().addAutoCachedPlaceholder(toCache);
plugin.extraDebug("Auto Caching placeholder " + toCache);
}
}
for (PlaceHolder<VotingPluginUser> placeholder : placeholders) {
if (placeholder.matches(toCache)) {
placeholder.setUseCache(true, toCache);
cachedPlaceholders.add(toCache);
plugin.getServerData().addAutoCachedPlaceholder(toCache);
plugin.extraDebug("Auto Caching placeholder " + toCache);
}
}
}
}
public void schedulePlaceholderCheck(VotingPluginUser user) {
plugin.getTimer().execute(new Runnable() {
@Override
public void run() {
checkNonCachedPlaceholders();
onUpdate(user);
}
});
}
public void onUpdate() {
checkNonCachedPlaceholders();
for (NonPlayerPlaceHolder<VotingPluginUser> placeholder : nonPlayerPlaceholders) {
if (placeholder.isUsesCache()) {
for (String ident : placeholder.getCache().keySet()) {
if (ident != null) {
String str = placeholder.placeholderRequest(ident);
if (str != null) {
placeholder.getCache().put(ident, str);
}
} else {
plugin.debug("ident null: " + placeholder.getIdentifier());
}
}
}
}
}
}
Loaded 100 of 115 files, more files were not shown because too many files have changed in this diff. Show more