Compare commits

..
512 Commits
Author SHA1 Message Date
BenCodez b217edeadf Update version number to 6.13 2023-05-14 13:15:00 -04:00
BenCodez aa4ad384c1 Adjustments to remove static usuage 2023-05-14 13:03:43 -04:00
BenCodez 8021024b48 Small change to reduce RAM usuage 2023-05-13 20:32:19 -04:00
BenCodez d3f246d048 Add extra customization to vote next GUI 2023-05-13 08:34:05 -04:00
BenCodez 9c2dfcab06 A lot of changes to getting all player data to prevent possible issues 2023-05-13 08:23:48 -04:00
BenCodez 8b4224a034 Add stats for background task time taken and remove playerdataloadlimit 2023-05-12 20:28:06 -04:00
BenCodez 61bf0007c1 Minor change to time changes 2023-05-10 20:44:56 -04:00
BenCodez 151559c50e Support time zones of proxies, improve speed of time changes 2023-05-10 20:24:45 -04:00
BenCodez 2dccf6e790 Add random player placeholder for vote party 2023-05-10 16:53:53 -04:00
BenCodez bc510b1ba0 Remove use of using 2 tasks 2023-05-09 20:57:03 -04:00
BenCodez 0253d86b8d Properly account canvote placeholder with timeoffsets and votedelaydaily 2023-05-07 21:12:38 -04:00
BenCodez 59cd31a6c8 Improve speed of background task 2023-05-07 20:52:35 -04:00
BenCodez 068b24bd39 Account for time offset in canvote placeholders 2023-05-07 19:03:56 -04:00
BenCodez 7f06797f5f Add placeholder for next available milestone data 2023-05-07 13:28:14 -04:00
BenCodez 3e2bdf4772 Remove duplicate placeholder cache update 2023-05-07 13:12:45 -04:00
BenCodez 3b049299b1 Adjust handling of recaching to optimize performance 2023-05-06 20:04:08 -04:00
BenCodez 05670bebeb Update placeholder cache on vote 2023-05-05 19:47:48 -04:00
BenCodez 81f73590a6 Switch to json files on velocity for vote caches 2023-05-04 20:47:51 -04:00
BenCodez 163e4cdadb Convert yaml files to json on bungeecord due to yaml size limit 2023-05-04 20:14:26 -04:00
BenCodez 512c02e501 Change default return of custom placeholders to return the value instead 2023-05-01 17:27:55 -04:00
BenCodez 25ef8ba315 Adjust to advancedcore changes 2023-05-01 17:24:17 -04:00
BenCodez 8966feb35a Change placeholder name to avoid conflict 2023-05-01 16:41:09 -04:00
BenCodez 0d29be48c7 Update version number to 6.12.2 2023-04-30 18:59:03 -04:00
BenCodez bc2827659d Add placeholder for number of votes until milestone 2023-04-30 16:17:35 -04:00
BenCodez 0a72247a5d Added a one time placeholder auto caching update 2023-04-30 14:59:22 -04:00
BenCodez a102ec3566 Revert placeholder reloading change 2023-04-30 14:39:39 -04:00
BenCodez f91b02d572 Change handling of placeholder reloading 2023-04-30 14:30:26 -04:00
BenCodez 0f00741151 Add extra failsafe on combined total on top voter storing 2023-04-30 14:10:20 -04:00
BenCodez 922302082f Implement new placeholder replacement system 2023-04-30 13:20:20 -04:00
BenCodez 24e1fbb6e5 Fix error 2023-04-30 12:51:45 -04:00
BenCodez 3026a2d48f Fix issue with placeholder 2023-04-30 12:42:02 -04:00
BenCodez 58101bfea0 Fixed top voter changes not working with sqlite 2023-04-30 12:40:22 -04:00
BenCodez 0a9e46ee85 Add placeholder %votingplugin_points_<number>% 2023-04-30 12:34:49 -04:00
BenCodez fd67e45c58 Add option for closing gui on click for top voter 2023-04-28 18:30:15 -04:00
BenCodez b6af6de2df Fix a few things 2023-04-27 17:00:01 -04:00
BenCodez 173051829e Implement close click handling to regular voteshop items 2023-04-26 19:44:30 -04:00
BenCodez 8a9ef4811f Make changes to CloseGUI option handling 2023-04-26 19:43:21 -04:00
BenCodez 4fd6d580b1 Implement same slot click system for vote shop extra items 2023-04-25 17:26:05 -04:00
BenCodez 415970101c Add CloseGUI option for VoteGUI 2023-04-24 18:52:35 -04:00
BenCodez 668dcdd8b4 Don't match exactly for votegui slots 2023-04-24 18:46:43 -04:00
BenCodez bf24533b54 Remove FLAT option 2023-04-23 20:31:40 -04:00
BenCodez b2daada576 Fix votetop GUI 2023-04-23 15:40:41 -04:00
BenCodez 9dd2c58134 Fix switch item 2023-04-23 15:30:55 -04:00
BenCodez 7674c68bc7 Add support for conditional items for rewards 2023-04-23 15:09:16 -04:00
BenCodez 0b3b0b29f5 Add more customization to top voter GUI 2023-04-23 14:29:41 -04:00
BenCodez 60370a1a83 Reload placeholder cache on reload 2023-04-23 12:43:58 -04:00
BenCodez 3bf273e854 Add to javascript engine main plugin instance 2023-04-22 15:38:33 -04:00
BenCodez a8e53c9b62 Added commands to reset voted sites 2023-04-22 15:27:16 -04:00
BenCodez 3015cd9604 Add placeholder for votegui 2023-04-22 09:02:16 -04:00
BenCodez 839119e0a9 Add sitesavailable placeholder for voteshop 2023-04-22 08:46:06 -04:00
BenCodez 409a0665cc Change multi-proxy socket handling for reloads 2023-04-21 21:32:07 -04:00
BenCodez 0549fe9c21 Add exit option to GUI for backbutton 2023-04-21 16:58:19 -04:00
BenCodez f047bb6176 Hide error for global data handling 2023-04-20 20:22:30 -04:00
BenCodez ad04b7e966 Fix voteshop message not working 2023-04-20 16:42:23 -04:00
BenCodez 2591cbf029 Add not buyable message to shop items 2023-04-19 19:15:21 -04:00
BenCodez 8213e07c74 Add support for extra items to voteshop 2023-04-19 19:08:29 -04:00
BenCodez 972f9581e3 Make /av placeholders command show placeholders as lowercase 2023-04-17 17:15:48 -04:00
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
115 changed files with 8251 additions and 4312 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.
Binary file not shown.
+64 -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,21 @@ 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
@@ -47,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
+297 -223
View File
@@ -1,13 +1,16 @@
# 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
# - MYSQL
DataStorage: SQLITE
@@ -22,87 +25,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 +82,9 @@ VoteReminding:
Message: '&cRemember to vote'
Delay: 30
# ------------------------------------------------
# Format
# ------------------------------------------------
###########################################
# Format options
###########################################
# Common PlacesHolders:
# Special PlaceHolders will be commented where available
@@ -132,7 +100,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 +112,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
@@ -274,6 +248,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
@@ -318,6 +296,7 @@ Format:
# Shop messages when using the /vote shop
ShopPurchase: '&aYou bought the %Identifier% for %Points% Points!'
ShopFailed: '&cYou do not have %Points% points to purchase this!'
ShopNotPurchasable: '&cThis item is not buyable!'
# User not exist message, from commands such as /vote next (player)
UserNotExist: '&cUser does not exist: %player%'
@@ -342,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
@@ -374,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.
@@ -382,109 +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
# Always force placeholders to return value if the value isn't cached
# This should prevent server from crashing when pulling placeholders on main thread
# Only affects placeholderapi placeholders
AlwaysWaitForCachePlaceholders: false
# If true, permissions will be handled differently
MultiplePermissionsCheck: false
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
@@ -506,16 +397,79 @@ 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
# Custom placeholder returns
# For the example below use %votingplugin_custom_enoughpoints_5%
# DO NOT USE ON MAIN THREAD IF POSSIBLE
# Keep everything lowercase
#CustomPlaceholderReturns:
# 'enoughpoints_5':
# 'true': 'User has enough points'
# 'false': 'User does not have enough points'
###########################################
# 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
@@ -526,6 +480,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
@@ -534,56 +579,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
@@ -594,13 +600,67 @@ 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
##########################################
# 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: 150
@@ -608,12 +668,32 @@ SpamClickTime: 150
# 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
# This will close GUI's if you shift click them rather than a regular
# This can help prevent exploits
CloseGUIOnShiftClick: false
###########################################
# 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
@@ -624,9 +704,3 @@ RequestAPI:
DefaultMethod: 'Anvil'
DisabledMethods: []
# Shouldn't need to change this
#AutoKillInvs: true
# Disable checking on world change
# May improve performance
#DisableCheckOnWorldChange: false
+32 -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
@@ -136,9 +139,14 @@ CHEST:
# %time% = time, using timeformat below
# %timesince% = time since vote
Line: '&6%timeSince%'
ClickableLinks: true
VoteNext:
Name: 'VoteNext: %player%'
BackButton: true
# Extra customization for displaying site names in GUI only
#CustomSiteNamesDisplays:
# Site1: site name display
LoreLine: '%time%'
VoteToday:
Name: 'VoteToday'
Line: '&6%VoteSite% : %Time%'
@@ -158,11 +166,17 @@ CHEST:
Lore: '&3&lVotes: &3%votes%'
# Opens main GUI of the specific player that gets clicked
OpenMainGUIOnClick: true
# Close GUI when clicking on a player item
CloseGUIOnClick: true
SwitchItem:
Name: '&3Switch TopVoter'
Lore: '&bCurrently: %Top%'
Material: 'OAK_SIGN'
Amount: 1
# Top voters for the switch item to use
#TopVoters:
#- ALLTIME
#- MONTHLY
# 8 Slots over from the bottom left
# Bottom of GUI
Slot: 7
@@ -173,6 +187,15 @@ CHEST:
# Item for player in GUI if use skull is false
PlayerItem:
Material: 'PAPER'
Customization:
Enabled: false
# List of slots for top voter
PlayerSlots: []
# Add extra items
ExtraItems: {}
RemoveBottomBar: false
# Set slot for backbutton
BackButtonSlot: 0
VoteTotal:
Name: 'VoteTotal: %player%'
BackButton: true
@@ -202,6 +225,7 @@ CHEST:
Amount: 1
VoteBest:
Name: 'VoteBest: %player%'
BackButton: true
DayBest:
Item:
Material: 'CLOCK'
@@ -274,6 +298,8 @@ CHEST:
OpenVoteURL: false
# If true, backbutton will be the last slot of the GUI
EndOfGUI: false
# If true, this item will become an exit button instead
Exit: false
VoteShopBackButton: true
VoteShopEnabled: true
@@ -283,6 +309,10 @@ CHEST:
VoteShopLimitReached: '&aYou reached your limit'
VoteShopRequireConfirmation: false
VoteShopDisabled: '&cVote shop disabled'
# VoteShop extra items for display only
#VoteShopExtraItems:
#Item:
#...
Shop:
# Identifier
# Used in placeholders for formats
+33 -7
View File
@@ -13,14 +13,26 @@ FirstVote:
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
@@ -28,7 +40,7 @@ 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
# Valid options
@@ -37,6 +49,11 @@ Cumulative:
# 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!'
@@ -55,7 +72,7 @@ VoteParty:
GiveAllPlayers: false
# If true, give online players the vote party reward
# Can also use RewardType: ONLINE if you wanted
GiveOnlinePlayersOnly: false
GiveOnlinePlayersOnly: true
# If true, the vote count will reset each day
ResetEachDay: false
# If true, the vote count will reset each week
@@ -64,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?
@@ -76,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
@@ -145,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
@@ -166,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
+121 -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,45 +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 -252
View File
@@ -1,252 +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
libraries:
- org.openjdk.nashorn:nashorn-core:15.2
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}'
+166 -124
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.4</version>
<artifactId>votingplugin</artifactId>
<version>6.13</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>
@@ -111,14 +103,10 @@
</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>
@@ -136,13 +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>org.bstats</pattern>
<!-- Replace this with your package! -->
<shadedPattern>${project.groupId}.votingplugin.bstats</shadedPattern>
<pattern>xyz.upperlevel.spigot</pattern>
<shadedPattern>${project.groupId}.votingplugin.advancedcore.xyz.upperlevel.spigot</shadedPattern>
</relocation>
</relocations>
</configuration>
@@ -175,50 +162,6 @@
</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>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>3.1.0</version>
@@ -251,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>
@@ -264,12 +206,16 @@
<id>velocity</id>
<url>https://nexus.velocitypowered.com/repository/maven-public/</url>
</repository>
<repository>
<id>bencodez repo</id>
<url>https://nexus.bencodez.com/repository/maven-public/</url>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>org.spigotmc</groupId>
<artifactId>spigot-api</artifactId>
<version>1.17-R0.1-SNAPSHOT</version>
<version>1.19.4-R0.1-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
<dependency>
@@ -281,27 +227,20 @@
<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.7.2</version>
<scope>system</scope>
<systemPath>${project.basedir}/Jars/nuvotifier.jar</systemPath>
</dependency>
<dependency>
<groupId>com.tchristofferson</groupId>
<artifactId>ConfigUpdater</artifactId>
<version>1.1-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>be.maximvdw</groupId>
<artifactId>MVdWPlaceholderAPI</artifactId>
<version>LATEST</version>
<scope>system</scope>
<systemPath>${project.basedir}/Jars/MVdWPlaceholderAPI.jar</systemPath>
<artifactId>mvdwplaceholderapi</artifactId>
<version>3.1.1</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.velocitypowered</groupId>
@@ -315,61 +254,164 @@
<version>2.2.1</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.bencodez</groupId>
<artifactId>advancedcore</artifactId>
<version>LATEST</version>
<scope>compile</scope>
</dependency>
</dependencies>
<profiles>
<profile>
<id>prod</id>
<activation>
<activeByDefault>true</activeByDefault>
</activation>
<properties>
<build.profile.id>prod</build.profile.id>
</properties>
<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>
@@ -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,24 +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.cache();
user.bungeeVotePluginMessaging(service, time, text, !setTotals, wasOnline);
if (plugin.getBungeeSettings().isPerServerPoints()) {
user.addPoints(plugin.getConfigFile().getPointsOnVote());
boolean broadcast = true;
boolean bungeeBroadcast = false;
if (args.size() > 9) {
bungeeBroadcast = Boolean.valueOf(args.get(9));
}
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);
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);
}
}
}
}
} 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))) {
@@ -119,11 +374,18 @@ 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();
user.cache();
if (plugin.getBungeeSettings().isPerServerPoints()) {
user.addPoints(plugin.getConfigFile().getPointsOnVote());
@@ -133,17 +395,51 @@ public class BungeeHandler {
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))) {
@@ -161,25 +457,55 @@ public class BungeeHandler {
String player = args.get(0);
plugin.debug("pluginmessaging voteupdate received for " + player);
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(UUID.fromString(player));
user.clearCache();
user.cache();
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));
}
}
});
@@ -193,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"));
@@ -202,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") {
@@ -218,7 +577,7 @@ public class BungeeHandler {
user = UserManager.getInstance().getVotingPluginUser(data[2]);
}
user.clearCache();
user.cache();
if (plugin.getBungeeSettings().isPerServerPoints()) {
user.addPoints(plugin.getConfigFile().getPointsOnVote());
@@ -229,6 +588,14 @@ public class BungeeHandler {
}
});
socketHandler.add(new SocketReceiver("BungeeTimeChange") {
@Override
public void onReceive(String[] data) {
checkGlobalData();
}
});
socketHandler.add(new SocketReceiver("bungeevoteonline") {
@Override
@@ -243,7 +610,7 @@ public class BungeeHandler {
user = UserManager.getInstance().getVotingPluginUser(data[2]);
}
user.clearCache();
user.cache();
if (plugin.getBungeeSettings().isPerServerPoints()) {
user.addPoints(plugin.getConfigFile().getPointsOnVote());
@@ -254,12 +621,25 @@ public class BungeeHandler {
}
});
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) {
@@ -271,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
@@ -291,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");
}
@@ -2,7 +2,6 @@ package com.bencodez.votingplugin;
import org.bukkit.entity.Player;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import com.bencodez.advancedcore.api.rewards.injected.RewardInject;
import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInject;
import com.bencodez.votingplugin.user.UserManager;
@@ -16,11 +15,11 @@ 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) {
@@ -16,7 +16,10 @@ import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TimerTask;
import java.util.UUID;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
@@ -43,15 +46,14 @@ import com.bencodez.advancedcore.api.misc.MiscUtils;
import com.bencodez.advancedcore.api.rewards.DirectlyDefinedReward;
import com.bencodez.advancedcore.api.rewards.Reward;
import com.bencodez.advancedcore.api.rewards.RewardEditData;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import com.bencodez.advancedcore.api.rewards.RewardPlaceholderHandle;
import com.bencodez.advancedcore.api.rewards.injected.RewardInject;
import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection;
import com.bencodez.advancedcore.api.rewards.injected.RewardInjectInt;
import com.bencodez.advancedcore.api.rewards.injected.RewardInjectValidator;
import com.bencodez.advancedcore.api.skull.SkullHandler;
import com.bencodez.advancedcore.api.updater.Updater;
import com.bencodez.advancedcore.api.user.UUID;
import com.bencodez.advancedcore.api.user.UserStorage;
import com.bencodez.advancedcore.api.user.userstorage.Column;
import com.bencodez.advancedcore.logger.Logger;
import com.bencodez.advancedcore.nms.NMSManager;
import com.bencodez.votingplugin.broadcast.BroadcastHandler;
@@ -80,8 +82,11 @@ import com.bencodez.votingplugin.placeholders.MVdWPlaceholders;
import com.bencodez.votingplugin.placeholders.PlaceHolders;
import com.bencodez.votingplugin.signs.Signs;
import com.bencodez.votingplugin.specialrewards.SpecialRewards;
import com.bencodez.votingplugin.test.VoteTester;
import com.bencodez.votingplugin.timequeue.TimeQueueHandler;
import com.bencodez.votingplugin.topvoter.TopVoter;
import com.bencodez.votingplugin.topvoter.TopVoterHandler;
import com.bencodez.votingplugin.topvoter.TopVoterPlayer;
import com.bencodez.votingplugin.updater.CheckUpdate;
import com.bencodez.votingplugin.user.UserManager;
import com.bencodez.votingplugin.user.VotingPluginUser;
@@ -134,17 +139,23 @@ public class VotingPluginMain extends AdvancedCorePlugin {
private GUI gui;
@Getter
private LinkedHashMap<VotingPluginUser, Integer> lastMonthTopVoter;
private LinkedHashMap<TopVoterPlayer, Integer> lastMonthTopVoter;
@Getter
private MVdWPlaceholders mvdwPlaceholders;
@Getter
private PlaceHolders placeholders;
@Getter
private VoteTester voteTester;
@Getter
private String profile = "";
@Getter
private String buildNumber = "NOTSET";
@Getter
private ServerData serverData;
@@ -162,7 +173,8 @@ public class VotingPluginMain extends AdvancedCorePlugin {
private String time = "";
@Getter
private LinkedHashMap<TopVoter, LinkedHashMap<VotingPluginUser, Integer>> topVoter;
@Setter
private LinkedHashMap<TopVoter, LinkedHashMap<TopVoterPlayer, Integer>> topVoter;
@Getter
private TopVoterHandler topVoterHandler;
@@ -195,21 +207,28 @@ public class VotingPluginMain extends AdvancedCorePlugin {
private List<VoteSite> voteSites;
@Getter
private LinkedHashMap<VotingPluginUser, HashMap<VoteSite, LocalDateTime>> voteToday;
@Setter
private LinkedHashMap<TopVoterPlayer, HashMap<VoteSite, LocalDateTime>> voteToday;
private boolean votifierLoaded = true;
@Getter
private boolean ymlError = false;
@Getter
private ScheduledExecutorService voteTimer;
@Getter
private UserManager votingPluginUserManager;
private void addDirectlyDefinedRewards(DirectlyDefinedReward directlyDefinedReward) {
RewardHandler.getInstance().addDirectlyDefined(directlyDefinedReward);
getRewardHandler().addDirectlyDefined(directlyDefinedReward);
}
public void basicBungeeUpdate() {
for (Player player : Bukkit.getOnlinePlayers()) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(player);
user.clearCache();
user.cache();
user.offVote();
user.checkOfflineRewards();
}
@@ -251,79 +270,8 @@ public class VotingPluginMain extends AdvancedCorePlugin {
}
}
public void convertDataStorage(UserStorage from, UserStorage to) {
if (from == null || to == null) {
throw new RuntimeException("Invalid Storage Method");
}
UserStorage cur = getStorageType();
getOptions().setStorageType(from);
if (getStorageType().equals(UserStorage.MYSQL) && getMysql() != null) {
getMysql().clearCache();
}
ArrayList<String> uuids = new ArrayList<String>(UserManager.getInstance().getAllUUIDs());
while (uuids.size() > 0) {
HashMap<VotingPluginUser, HashMap<String, String>> data = new HashMap<VotingPluginUser, HashMap<String, String>>();
getOptions().setStorageType(from);
loadUserAPI(getOptions().getStorageType());
// setStorageType(to);
if (getStorageType().equals(UserStorage.MYSQL) && getMysql() != null) {
getMysql().clearCache();
}
ArrayList<String> converted = new ArrayList<String>();
int i = 0;
while (i < configFile.getConvertAmount() && i < uuids.size()) {
String uuid = uuids.get(i);
try {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(new UUID(uuid));
HashMap<String, String> values = new HashMap<String, String>();
for (String key : user.getData().getKeys()) {
String value = user.getData().getValue(key);
if (value != null && !value.isEmpty() && !value.equalsIgnoreCase("null")) {
values.put(key, value);
}
}
i++;
converted.add(uuid);
data.put(user, values);
debug("[Convert] Added " + uuid);
} catch (Exception e) {
debug(e);
plugin.getLogger().warning("Exception occoured for '" + uuid + "': " + e.getMessage()
+ ", turn debug on to see full stack traces");
}
}
try {
wait(configFile.getConvertDelay());
} catch (Exception e) {
}
uuids.removeAll(converted);
plugin.getLogger().info("Finished getting data from " + from.toString() + " Converting " + data.size()
+ " users, " + uuids.size() + " left to convert");
getOptions().setStorageType(to);
loadUserAPI(getOptions().getStorageType());
if (getStorageType().equals(UserStorage.MYSQL) && getMysql() != null) {
getMysql().clearCache();
}
writeConvertData(data);
}
getOptions().setStorageType(cur);
reload();
plugin.getLogger().info("Finished convertting");
}
public ArrayList<VotingPluginUser> convertSet(Set<VotingPluginUser> set) {
return new ArrayList<VotingPluginUser>(set);
public ArrayList<TopVoterPlayer> convertSet(Set<TopVoterPlayer> set) {
return new ArrayList<TopVoterPlayer>(set);
}
@Override
@@ -331,8 +279,12 @@ public class VotingPluginMain extends AdvancedCorePlugin {
return configFile.getData();
}
public LinkedHashMap<VotingPluginUser, Integer> getTopVoter(TopVoter top) {
return topVoter.get(top);
public LinkedHashMap<TopVoterPlayer, Integer> getTopVoter(TopVoter top) {
LinkedHashMap<TopVoterPlayer, Integer> top1 = topVoter.get(top);
if (top1 == null) {
top1 = new LinkedHashMap<TopVoterPlayer, Integer>();
}
return top1;
}
/**
@@ -373,20 +325,14 @@ public class VotingPluginMain extends AdvancedCorePlugin {
return null;
}
/**
* Gets the vote site.
*
* @param site the site name
* @return the vote site
*/
public VoteSite getVoteSite(String site) {
String siteName = getVoteSiteName(site);
public VoteSite getVoteSite(String site, boolean checkEnabled) {
String siteName = getVoteSiteName(checkEnabled, site);
for (VoteSite voteSite : getVoteSites()) {
if (voteSite.getKey().equalsIgnoreCase(siteName) || voteSite.getDisplayName().equals(siteName)) {
return voteSite;
}
}
if (configFile.isAutoCreateVoteSites() && !configVoteSites.getVoteSitesNames().contains(siteName)) {
if (configFile.isAutoCreateVoteSites() && !configVoteSites.getVoteSitesNames(false).contains(siteName)) {
configVoteSites.generateVoteSite(siteName);
return new VoteSite(plugin, siteName.replace(".", "_"));
}
@@ -394,14 +340,8 @@ public class VotingPluginMain extends AdvancedCorePlugin {
}
/**
* Gets the vote site name.
*
* @param urls the url
* @return the vote site name
*/
public String getVoteSiteName(String... urls) {
ArrayList<String> sites = getConfigVoteSites().getVoteSitesNames();
public String getVoteSiteName(boolean checkEnabled, String... urls) {
ArrayList<String> sites = getConfigVoteSites().getVoteSitesNames(checkEnabled);
for (String url : urls) {
if (url == null) {
return null;
@@ -414,11 +354,10 @@ public class VotingPluginMain extends AdvancedCorePlugin {
return siteName;
}
}
}
for (String siteName : sites) {
if (siteName.equalsIgnoreCase(url)) {
return siteName;
}
}
}
return url;
@@ -431,7 +370,7 @@ public class VotingPluginMain extends AdvancedCorePlugin {
}
public String getVoteSiteServiceSite(String name) {
ArrayList<String> sites = getConfigVoteSites().getVoteSitesNames();
ArrayList<String> sites = getConfigVoteSites().getVoteSitesNames(true);
if (name == null) {
return null;
}
@@ -452,12 +391,8 @@ public class VotingPluginMain extends AdvancedCorePlugin {
}
public UserManager getVotingPluginUserManager() {
return UserManager.getInstance();
}
public boolean hasVoteSite(String site) {
String siteName = getVoteSiteName(site);
String siteName = getVoteSiteName(false, site);
for (VoteSite voteSite : getVoteSites()) {
if (voteSite.getKey().equalsIgnoreCase(siteName) || voteSite.getDisplayName().equals(siteName)) {
return true;
@@ -476,7 +411,7 @@ public class VotingPluginMain extends AdvancedCorePlugin {
}
public void loadDirectlyDefined() {
RewardHandler.getInstance().getDirectlyDefinedRewards().clear();
getRewardHandler().getDirectlyDefinedRewards().clear();
// AllSites reward
addDirectlyDefinedRewards(new DirectlyDefinedReward("AllSites") {
@@ -501,6 +436,29 @@ public class VotingPluginMain extends AdvancedCorePlugin {
}
});
addDirectlyDefinedRewards(new DirectlyDefinedReward("AlmostAllSites") {
@Override
public void createSection(String key) {
getSpecialRewardsConfig().createSection(key);
}
@Override
public ConfigurationSection getFileData() {
return getSpecialRewardsConfig().getData();
}
@Override
public void save() {
getSpecialRewardsConfig().saveData();
}
@Override
public void setData(String path, Object value) {
getSpecialRewardsConfig().setValue(path, value);
}
});
// FirstVote
addDirectlyDefinedRewards(new DirectlyDefinedReward("FirstVote") {
@@ -524,7 +482,7 @@ public class VotingPluginMain extends AdvancedCorePlugin {
getSpecialRewardsConfig().setValue(path, value);
}
});
addDirectlyDefinedRewards(new DirectlyDefinedReward("FirstVoteToday") {
@Override
@@ -790,6 +748,29 @@ public class VotingPluginMain extends AdvancedCorePlugin {
getConfigVoteSites().setValue(path, value);
}
});
addDirectlyDefinedRewards(new DirectlyDefinedReward("VoteSites." + site.getKey() + ".CoolDownEndRewards") {
@Override
public void createSection(String key) {
getConfigVoteSites().createSection(key);
}
@Override
public ConfigurationSection getFileData() {
return getConfigVoteSites().getData();
}
@Override
public void save() {
getConfigVoteSites().saveData();
}
@Override
public void setData(String path, Object value) {
getConfigVoteSites().setValue(path, value);
}
});
}
// vote streaks
@@ -924,6 +905,28 @@ public class VotingPluginMain extends AdvancedCorePlugin {
});
}
addDirectlyDefinedRewards(new DirectlyDefinedReward("BungeeVotePartyRewards") {
@Override
public void createSection(String key) {
getBungeeSettings().createSection(key);
}
@Override
public ConfigurationSection getFileData() {
return getBungeeSettings().getData();
}
@Override
public void save() {
getBungeeSettings().saveData();
}
@Override
public void setData(String path, Object value) {
getBungeeSettings().setValue(path, value);
}
});
}
private void loadTimer() {
@@ -931,31 +934,25 @@ public class VotingPluginMain extends AdvancedCorePlugin {
@Override
public void run() {
getTimer().schedule(new TimerTask() {
getTimer().scheduleWithFixedDelay(new Runnable() {
@Override
public void run() {
if (plugin != null) {
update();
} else {
cancel();
}
}
}, 1000, 1000 * 60 * configFile.getDelayBetweenUpdates());
}, 1000, 1000 * 60 * configFile.getDelayBetweenUpdates(), TimeUnit.MILLISECONDS);
coolDownCheck.load();
getTimer().schedule(new TimerTask() {
getTimer().scheduleWithFixedDelay(new Runnable() {
@Override
public void run() {
if (plugin != null && configFile.isExtraBackgroundUpdate()) {
basicBungeeUpdate();
} else {
cancel();
}
}
}, 1000, 1000 * 30);
}, 1000, 1000 * 30, TimeUnit.MILLISECONDS);
}
}, 40L);
@@ -967,6 +964,7 @@ public class VotingPluginMain extends AdvancedCorePlugin {
if (conf != null) {
time = conf.getString("time", "");
profile = conf.getString("profile", "");
buildNumber = conf.getString("buildnumber", "NOTSET");
}
}
@@ -1005,13 +1003,25 @@ public class VotingPluginMain extends AdvancedCorePlugin {
* Metrics.
*/
private void metrics() {
new VotingPluginMetrics().load(this);
new VotingPluginMetrics().load(plugin);
}
private void loadVoteTimer() {
voteTimer = Executors.newSingleThreadScheduledExecutor();
}
@Getter
private TimeQueueHandler timeQueueHandler;
@Override
public void onPostLoad() {
loadVersionFile();
getOptions().setServer(bungeeSettings.getServer());
voteTester = new VoteTester(plugin);
loadVoteTimer();
if (bungeeSettings.isUseBungeecoord()) {
bungeeHandler = new BungeeHandler(this);
bungeeHandler.load();
@@ -1023,6 +1033,10 @@ public class VotingPluginMain extends AdvancedCorePlugin {
}
if (!bungeeSettings.isUseBungeecoord() || !bungeeSettings.isGloblalDataEnabled()) {
this.timeQueueHandler = new TimeQueueHandler(this);
}
registerCommands();
checkVotifier();
registerEvents();
@@ -1034,6 +1048,9 @@ public class VotingPluginMain extends AdvancedCorePlugin {
specialRewards = new SpecialRewards(this);
signs = new Signs(this);
coolDownCheck.checkEnabled();
coolDownCheck.load();
Bukkit.getScheduler().runTask(plugin, new Runnable() {
@Override
@@ -1043,7 +1060,7 @@ public class VotingPluginMain extends AdvancedCorePlugin {
});
topVoterHandler = new TopVoterHandler(this);
lastMonthTopVoter = new LinkedHashMap<VotingPluginUser, Integer>();
lastMonthTopVoter = new LinkedHashMap<TopVoterPlayer, Integer>();
Bukkit.getScheduler().runTaskAsynchronously(plugin, new Runnable() {
@Override
@@ -1052,11 +1069,11 @@ public class VotingPluginMain extends AdvancedCorePlugin {
debug("Loaded last month top voters");
}
});
topVoter = new LinkedHashMap<TopVoter, LinkedHashMap<VotingPluginUser, Integer>>();
topVoter = new LinkedHashMap<TopVoter, LinkedHashMap<TopVoterPlayer, Integer>>();
for (TopVoter top : TopVoter.values()) {
topVoter.put(top, new LinkedHashMap<VotingPluginUser, Integer>());
topVoter.put(top, new LinkedHashMap<TopVoterPlayer, Integer>());
}
voteToday = new LinkedHashMap<VotingPluginUser, HashMap<VoteSite, LocalDateTime>>();
voteToday = new LinkedHashMap<TopVoterPlayer, HashMap<VoteSite, LocalDateTime>>();
voteLog = new Logger(plugin, new File(plugin.getDataFolder() + File.separator + "Log", "votelog.txt"));
new AdminGUI(this).loadHook();
@@ -1067,7 +1084,13 @@ public class VotingPluginMain extends AdvancedCorePlugin {
topVoterHandler.register();
metrics();
Bukkit.getScheduler().runTaskAsynchronously(plugin, new Runnable() {
@Override
public void run() {
metrics();
}
});
// javascript api
getJavascriptEngineRequests().add(new JavascriptPlaceholderRequest("User") {
@@ -1078,11 +1101,13 @@ public class VotingPluginMain extends AdvancedCorePlugin {
}
});
getJavascriptEngine().put("VotingPluginHooks", VotingPluginHooks.getInstance());
getJavascriptEngine().put("VotingPlugin", this);
loadTimer();
// placeholderapi loading
placeholders = new PlaceHolders(this);
getServerData().updatePlaceholders();
placeholders.load();
if (Bukkit.getPluginManager().isPluginEnabled("MVdWPlaceholderAPI")) {
@@ -1090,46 +1115,18 @@ public class VotingPluginMain extends AdvancedCorePlugin {
mvdwPlaceholders.loadMVdWPlaceholders();
}
// set columns
if (getStorageType().equals(UserStorage.MYSQL) && configFile.isAlterColumns()) {
getMysql().alterColumnType("TopVoterIgnore", "VARCHAR(5)");
getMysql().alterColumnType("CheckWorld", "VARCHAR(5)");
getMysql().alterColumnType("Reminded", "VARCHAR(5)");
getMysql().alterColumnType("DisableBroadcast", "VARCHAR(5)");
getMysql().alterColumnType("LastOnline", "VARCHAR(20)");
getMysql().alterColumnType("PlayerName", "VARCHAR(30)");
getMysql().alterColumnType("DailyTotal", "INT DEFAULT '0'");
getMysql().alterColumnType("WeeklyTotal", "INT DEFAULT '0'");
getMysql().alterColumnType("DayVoteStreak", "INT DEFAULT '0'");
getMysql().alterColumnType("BestDayVoteStreak", "INT DEFAULT '0'");
getMysql().alterColumnType("WeekVoteStreak", "INT DEFAULT '0'");
getMysql().alterColumnType("BestWeekVoteStreak", "INT DEFAULT '0'");
getMysql().alterColumnType("VotePartyVotes", "INT DEFAULT '0'");
getMysql().alterColumnType("MonthVoteStreak", "INT DEFAULT '0'");
getMysql().alterColumnType("Points", "INT DEFAULT '0'");
getMysql().alterColumnType("HighestDailyTotal", "INT DEFAULT '0'");
getMysql().alterColumnType("AllTimeTotal", "INT DEFAULT '0'");
getMysql().alterColumnType("HighestMonthlyTotal", "INT DEFAULT '0'");
getMysql().alterColumnType("MilestoneCount", "INT DEFAULT '0'");
getMysql().alterColumnType("MonthTotal", "INT DEFAULT '0'");
getMysql().alterColumnType("HighestWeeklyTotal", "INT DEFAULT '0'");
getMysql().alterColumnType("LastMonthTotal", "INT DEFAULT '0'");
getMysql().alterColumnType("OfflineRewards", "MEDIUMTEXT");
getMysql().alterColumnType("DayVoteStreakLastUpdate", "MEDIUMTEXT");
if (getOptions().isPerServerRewards()) {
getMysql().alterColumnType("OfflineRewards" + getOptions().getServer(), "MEDIUMTEXT");
}
}
// Add rewards
RewardHandler.getInstance().addInjectedReward(new RewardInjectInt("Points", 0) {
getRewardHandler().addInjectedReward(new RewardInjectInt("Points", 0) {
@Override
public String onRewardRequest(Reward reward, com.bencodez.advancedcore.api.user.AdvancedCoreUser user,
int num, HashMap<String, String> placeholders) {
UserManager.getInstance().getVotingPluginUser(user).addPoints(num);
return null;
VotingPluginUser vpUser = UserManager.getInstance().getVotingPluginUser(user);
String str = "" + vpUser.addPoints(num);
debug("Setting points to " + str);
return str;
}
}.synchronize().addEditButton(
}.synchronize().asPlaceholder("newpoints").addEditButton(
new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueNumber("Points", null) {
@Override
@@ -1147,7 +1144,7 @@ public class VotingPluginMain extends AdvancedCorePlugin {
}
}));
RewardHandler.getInstance().addInjectedReward(new RewardInjectConfigurationSection("VoteBossBar") {
getRewardHandler().addInjectedReward(new RewardInjectConfigurationSection("VoteBossBar") {
@Override
public String onRewardRequested(Reward arg0, com.bencodez.advancedcore.api.user.AdvancedCoreUser user,
@@ -1166,7 +1163,7 @@ public class VotingPluginMain extends AdvancedCorePlugin {
});
for (final TopVoter top : TopVoter.values()) {
RewardHandler.getInstance().addPlaceholder(new RewardPlaceholderHandle("Total_" + top.toString()) {
getRewardHandler().addPlaceholder(new RewardPlaceholderHandle("Total_" + top.toString()) {
@Override
public String getValue(Reward reward, com.bencodez.advancedcore.api.user.AdvancedCoreUser user) {
@@ -1183,10 +1180,11 @@ public class VotingPluginMain extends AdvancedCorePlugin {
plugin.getLogger().info("Enabled VotingPlugin " + plugin.getDescription().getVersion());
if (getProfile().contains("dev")) {
plugin.getLogger().warning("Using dev build, this is not a stable build, use at your own risk");
plugin.getLogger().info(
"Using dev build, this is not a stable build, use at your own risk. Build number: " + buildNumber);
}
boolean hasRewards = RewardHandler.getInstance().hasRewards(getConfigVoteSites().getData(),
boolean hasRewards = getRewardHandler().hasRewards(getConfigVoteSites().getData(),
getConfigVoteSites().getEverySiteRewardPath());
boolean issues = true;
@@ -1195,7 +1193,7 @@ public class VotingPluginMain extends AdvancedCorePlugin {
if (!site.hasRewards() && !hasRewards) {
issues = false;
plugin.getLogger().warning("No rewards detected for the site: " + site.getKey()
+ ". See https://github.com/Ben12345rocks/AdvancedCore/wiki/Rewards on how to add rewards");
+ ". See https://github.com/BenCodez/VotingPlugin/wiki/Rewards");
}
boolean contains = false;
@@ -1217,7 +1215,7 @@ public class VotingPluginMain extends AdvancedCorePlugin {
@Override
public void run() {
plugin.getLogger().warning(
"Detected an issue with voting sites, check the server startup log for more details");
"Detected an issue with voting sites, check the server startup log for more details: https://github.com/BenCodez/VotingPlugin/wiki/Votifier-Troubleshooting");
}
}, 30l);
}
@@ -1250,7 +1248,10 @@ public class VotingPluginMain extends AdvancedCorePlugin {
loadVoteSites();
setJenkinsSite("ben12345rocks.com");
votingPluginUserManager = UserManager.getInstance();
votingPluginUserManager.addCachingKeys();
setJenkinsSite("bencodez.com");
updateAdvancedCoreHook();
}
@@ -1262,8 +1263,6 @@ public class VotingPluginMain extends AdvancedCorePlugin {
*/
@Override
public void onUnLoad() {
getSigns().storeSigns();
HandlerList.unregisterAll(plugin);
if (bungeeSettings.isUseBungeecoord()) {
try {
getBungeeHandler().close();
@@ -1271,6 +1270,18 @@ public class VotingPluginMain extends AdvancedCorePlugin {
debug(e);
}
}
voteTimer.shutdown();
try {
voteTimer.awaitTermination(10, TimeUnit.SECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
voteTimer.shutdownNow();
if (timeQueueHandler != null) {
timeQueueHandler.save();
}
getSigns().storeSigns();
HandlerList.unregisterAll(plugin);
plugin = null;
}
@@ -1291,8 +1302,10 @@ public class VotingPluginMain extends AdvancedCorePlugin {
// /adminvote, /av
getCommand("adminvote").setExecutor(new CommandAdminVote(this));
getCommand("adminvote").setTabCompleter(new AdminVoteTabCompleter());
getCommand("adminvote").setPermission("VotingPlugin.Commands.AdminVote");
getCommand("av").setExecutor(new CommandAdminVote(this));
getCommand("av").setTabCompleter(new AdminVoteTabCompleter());
getCommand("av").setPermission("VotingPlugin.Commands.AdminVote");
Permission perm = Bukkit.getPluginManager().getPermission("VotingPlugin.Player");
if (perm != null) {
@@ -1325,6 +1338,10 @@ public class VotingPluginMain extends AdvancedCorePlugin {
pm.registerEvents(new PlayerInteract(this), this);
}
if (timeQueueHandler != null) {
pm.registerEvents(timeQueueHandler, plugin);
}
pm.registerEvents(new VotingPluginUpdateEvent(this), this);
/*
* if (!NMSManager.getInstance().isVersion("1.12")) { pm.registerEvents(new
@@ -1350,8 +1367,6 @@ public class VotingPluginMain extends AdvancedCorePlugin {
}
private void reloadPlugin(boolean userStorage) {
setUpdate(true);
configFile.reloadData();
configFile.loadValues();
@@ -1362,10 +1377,14 @@ public class VotingPluginMain extends AdvancedCorePlugin {
gui.reloadData();
bungeeSettings.reloadData();
if (bungeeSettings.isUseBungeecoord()) {
getBungeeHandler().loadGlobalMysql();
}
checkYMLError();
if (broadcastHandler != null) {
broadcastHandler.schelude(getConfigFile().getFormatAlternateBroadcastDelay());
broadcastHandler.schedule(getConfigFile().getFormatAlternateBroadcastDelay());
}
updateAdvancedCoreHook();
@@ -1373,15 +1392,15 @@ public class VotingPluginMain extends AdvancedCorePlugin {
loadDirectlyDefined();
reloadAdvancedCore(userStorage);
getOptions().setServer(bungeeSettings.getServer());
placeholders.load();
if (userStorage) {
placeholders.load();
placeholders.reload();
}
Bukkit.getScheduler().runTaskAsynchronously(plugin, new Runnable() {
voteReminding.loadRemindChecking();
coolDownCheck.checkEnabled();
@Override
public void run() {
update();
}
});
setUpdate(true);
}
private void setupFiles() {
@@ -1405,12 +1424,11 @@ public class VotingPluginMain extends AdvancedCorePlugin {
checkYMLError();
plugin.debug("Loaded Files");
}
/**
* Update.
*/
@Getter
private long lastBackgroundTaskTimeTaken = -1;
public void update() {
if (update || configFile.isAlwaysUpdate()) {
if (!updateStarted && plugin != null) {
@@ -1419,51 +1437,127 @@ public class VotingPluginMain extends AdvancedCorePlugin {
update = false;
synchronized (plugin) {
if (getStorageType().equals(UserStorage.MYSQL)) {
if (getMysql() == null) {
plugin.debug("MySQL not loaded yet");
return;
} else if (configFile.isClearCacheOnUpdate() || bungeeSettings.isUseBungeecoord()) {
getMysql().clearCache();
} else {
getMysql().clearCacheBasic();
}
}
if (plugin != null && plugin.isEnabled()) {
getUserManager().getDataManager().clearCacheBasic();
plugin.debug("Starting background task");
long time = System.currentTimeMillis();
try {
ArrayList<String> uuids = UserManager.getInstance().getAllUUIDs();
ArrayList<VotingPluginUser> users = new ArrayList<VotingPluginUser>();
for (String uuid : uuids) {
if (uuid != null && !uuid.isEmpty()) {
VotingPluginUser user = UserManager.getInstance()
.getVotingPluginUser(new UUID(uuid));
users.add(user);
// extraDebug("Loading " + uuid);
// java.lang.Thread.sleep(5000);
}
}
update = false;
long time1 = ((System.currentTimeMillis() - time) / 1000);
plugin.debug("Finished loading player data in " + time1 + " seconds, " + users.size()
+ " users");
topVoterHandler.updateTopVoters(users);
updateVoteToday(users);
serverData.updateValues();
getSigns().updateSigns();
plugin.debug("Starting background task, current cached users: "
+ plugin.getUserManager().getDataManager().getUserDataCache().keySet().size());
if (!configFile.isExtraBackgroundUpdate()) {
for (Player player : Bukkit.getOnlinePlayers()) {
VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(player);
user.offVote();
try {
boolean extraBackgroundUpdate = configFile.isExtraBackgroundUpdate();
long startTime = System.currentTimeMillis();
LinkedHashMap<TopVoterPlayer, HashMap<VoteSite, LocalDateTime>> voteToday = new LinkedHashMap<TopVoterPlayer, HashMap<VoteSite, LocalDateTime>>();
LinkedHashMap<TopVoter, LinkedHashMap<TopVoterPlayer, Integer>> tempTopVoter = new LinkedHashMap<TopVoter, LinkedHashMap<TopVoterPlayer, Integer>>();
ArrayList<TopVoter> topVotersToCheck = new ArrayList<TopVoter>();
for (TopVoter top : TopVoter.values()) {
if (plugin == null) {
return;
}
if (plugin.getConfigFile().getLoadTopVoter(top)) {
topVotersToCheck.add(top);
tempTopVoter.put(top, new LinkedHashMap<TopVoterPlayer, Integer>());
}
}
boolean topVoterIgnorePermissionUse = plugin.getConfigFile()
.getTopVoterIgnorePermission();
ArrayList<String> blackList = plugin.getConfigFile().getBlackList();
// ArrayList<String> uuids = UserManager.getInstance().getAllUUIDs();
int currentDay = LocalDateTime.now().getDayOfMonth();
HashMap<UUID, ArrayList<Column>> cols = plugin.getUserManager().getAllKeys();
long time1 = ((System.currentTimeMillis() - startTime) / 1000);
plugin.debug("Finished getting player data in " + time1 + " seconds, " + cols.size()
+ " users, " + plugin.getStorageType().toString());
time1 = System.currentTimeMillis();
for (Entry<UUID, ArrayList<Column>> playerData : cols.entrySet()) {
String uuid = playerData.getKey().toString();
if (plugin != null && plugin.isEnabled()) {
if (uuid != null && !uuid.isEmpty()) {
VotingPluginUser user = UserManager.getInstance()
.getVotingPluginUser(UUID.fromString(uuid), false);
user.dontCache();
user.updateTempCacheWithColumns(playerData.getValue());
cols.put(playerData.getKey(), null);
if (!user.isBanned() && !blackList.contains(user.getPlayerName())) {
if (!topVoterIgnorePermissionUse || !user.isTopVoterIgnore()) {
for (TopVoter top : topVotersToCheck) {
int total = user.getTotal(top);
if (total > 0) {
tempTopVoter.get(top).put(user.getTopVoterPlayer(), total);
}
}
}
HashMap<VoteSite, LocalDateTime> times = new HashMap<VoteSite, LocalDateTime>();
for (Entry<VoteSite, Long> entry : user.getLastVotes().entrySet()) {
if (entry.getKey().isEnabled() && !entry.getKey().isHidden()) {
long time = entry.getValue();
if ((currentDay == MiscUtils.getInstance().getDayFromMili(time))
&& (LocalDateTime.now().getMonthValue() == MiscUtils
.getInstance().getMonthFromMili(time))
&& (LocalDateTime.now().getYear() == MiscUtils
.getInstance().getYearFromMili(time))) {
times.put(entry.getKey(),
LocalDateTime.ofInstant(Instant.ofEpochMilli(time),
ZoneId.systemDefault()));
}
}
}
if (times.keySet().size() > 0) {
voteToday.put(user.getTopVoterPlayer(), times);
}
}
if (extraBackgroundUpdate) {
if (user.isOnline()) {
user.offVote();
}
}
if (plugin != null) {
plugin.getPlaceholders().onUpdate(user);
}
user.clearTempCache();
user = null;
}
} else {
return;
}
}
cols.clear();
cols = null;
topVoterHandler.updateTopVoters(tempTopVoter);
placeholders.onUpdate();
setVoteToday(voteToday);
serverData.updateValues();
getSigns().updateSigns();
checkFirstTimeLoaded();
plugin.getUserManager().getDataManager().clearNonNeededCachedUsers();
plugin.extraDebug("Current cached users: "
+ plugin.getUserManager().getDataManager().getUserDataCache().keySet().size());
update = false;
tempTopVoter = null;
time1 = ((System.currentTimeMillis() - time1) / 1000);
long totalTime = ((System.currentTimeMillis() - startTime) / 1000);
lastBackgroundTaskTimeTaken = totalTime;
plugin.debug("Background task finished. Final processing took " + time1
+ " seconds. Total time: " + totalTime + " seconds");
} catch (Exception ex) {
if (plugin != null) {
plugin.getLogger().info("Looks like something went wrong");
}
ex.printStackTrace();
}
time1 = ((System.currentTimeMillis() - time) / 1000);
plugin.debug("Background task finished in " + time1 + " seconds");
} catch (Exception ex) {
plugin.getLogger().info("Looks like something went wrong");
ex.printStackTrace();
}
}
@@ -1473,65 +1567,35 @@ public class VotingPluginMain extends AdvancedCorePlugin {
}
}
private boolean firstTimeLoaded = false;
public void checkFirstTimeLoaded() {
if (!firstTimeLoaded) {
if (getGui().isChestVoteTopUseSkull()) {
int maxToLoad = 200;
for (TopVoter top : topVoter.keySet()) {
int num = 1;
Set<TopVoterPlayer> players = topVoter.get(top).keySet();
for (TopVoterPlayer p : players) {
if (num <= maxToLoad) {
SkullHandler.getInstance().loadSkull(p.getPlayerName());
}
num++;
}
}
}
}
firstTimeLoaded = true;
}
public void updateAdvancedCoreHook() {
getJavascriptEngine().put("VotingPlugin", this);
allowDownloadingFromSpigot(15358);
setConfigData(configFile.getData());
if (bungeeSettings.isUseBungeecoord()) {
getOptions().setClearCacheOnJoin(true);
getOptions().setPerServerRewards(getBungeeSettings().isPerServerRewards());
}
}
public void updateVoteToday(ArrayList<VotingPluginUser> users) {
plugin.getVoteToday().clear();
for (VotingPluginUser user : users) {
HashMap<VoteSite, LocalDateTime> times = new HashMap<VoteSite, LocalDateTime>();
for (VoteSite voteSite : plugin.getVoteSites()) {
if (!voteSite.isHidden()) {
long time = user.getTime(voteSite);
if ((LocalDateTime.now().getDayOfMonth() == MiscUtils.getInstance().getDayFromMili(time))
&& (LocalDateTime.now().getMonthValue() == MiscUtils.getInstance().getMonthFromMili(time))
&& (LocalDateTime.now().getYear() == MiscUtils.getInstance().getYearFromMili(time))) {
times.put(voteSite,
LocalDateTime.ofInstant(Instant.ofEpochMilli(time), ZoneId.systemDefault()));
}
}
}
if (times.keySet().size() > 0) {
plugin.getVoteToday().put(user, times);
}
}
plugin.debug("Updated VoteToday");
}
private void writeConvertData(HashMap<VotingPluginUser, HashMap<String, String>> data) {
boolean checkInt = getStorageType().equals(UserStorage.MYSQL);
for (Entry<VotingPluginUser, HashMap<String, String>> entry : data.entrySet()) {
try {
for (Entry<String, String> values : entry.getValue().entrySet()) {
String value = values.getValue();
if (value != null && !value.equalsIgnoreCase("null")) {
if (checkInt) {
if (StringParser.getInstance().isInt(value)) {
entry.getKey().getData().setInt(values.getKey(), Integer.parseInt(value));
} else {
entry.getKey().getData().setString(values.getKey(), value);
}
} else {
entry.getKey().getData().setString(values.getKey(), value);
}
}
}
} catch (Exception e) {
e.printStackTrace();
plugin.getLogger()
.warning("Exception occoured for '" + entry.getKey().getUUID() + "': " + e.getMessage());
}
}
}
}
@@ -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,149 +150,223 @@ 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") {
metrics.addCustomChart(new BStatsMetrics.SimplePie("bungeebroadcast", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
return "" + plugin.getBungeeSettings().isBungeeBroadcast();
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("bungeebroadcastalways") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("bungeebroadcastalways", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
return "" + plugin.getBungeeSettings().isBungeeBroadcastAlways();
}
});
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("perserverrewards") {
metrics.addCustomChart(new BStatsMetrics.SimplePie("perserverrewards", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
return "" + plugin.getBungeeSettings().isPerServerRewards();
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("perserverpoints") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("perserverpoints", new Callable<String>() {
@Override
public String getValue() {
public String call() throws Exception {
return "" + plugin.getBungeeSettings().isPerServerPoints();
}
});
metrics.addCustomChart(new BStatsMetrics.SimplePie("triggervotifierevent") {
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("triggervotifierevent", new Callable<String>() {
@Override
public String getValue() {
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("geyserprefixsupport") {
metrics.addCustomChart(new BStatsMetrics.SimplePie("persitecooldownevents", new Callable<String>() {
@Override
public String getValue() {
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") {
metrics.addCustomChart(new BStatsMetrics.SimplePie("using_dev_build", new Callable<String>() {
@Override
public String getValue() {
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"));
}
}));
metrics.addCustomChart(new BStatsMetrics.SimplePie("background_task_time_taken", new Callable<String>() {
@Override
public String call() throws Exception {
return "" + plugin.getLastBackgroundTaskTimeTaken();
}
}));
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;
@@ -16,12 +17,12 @@ import com.bencodez.votingplugin.user.UserManager;
public class BroadcastHandler {
private VotingPluginMain plugin;
private Timer timer;
private ScheduledExecutorService timer;
ConcurrentLinkedQueue<String> votedPlayers = new ConcurrentLinkedQueue<String>();
public BroadcastHandler(VotingPluginMain plugin, int delay) {
this.plugin = plugin;
schelude(delay);
schedule(delay);
}
public void check() {
@@ -32,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()) {
@@ -50,18 +59,19 @@ public class BroadcastHandler {
votedPlayers.add(player);
}
public void schelude(int delay) {
public void schedule(int delay) {
if (timer != null) {
timer.cancel();
timer.shutdownNow();
timer = Executors.newScheduledThreadPool(1);
} else {
timer = new Timer();
timer = Executors.newScheduledThreadPool(1);
}
timer.schedule(new TimerTask() {
timer.scheduleWithFixedDelay(new Runnable() {
@Override
public void run() {
check();
}
}, 1000 * 60, 1000 * 60 * delay);
}, 60, 60 * delay, TimeUnit.SECONDS);
}
}
@@ -7,7 +7,7 @@ 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;
@@ -21,15 +21,21 @@ public class BungeeMessageData {
private int points = 0;
@Getter
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 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) {
@@ -42,12 +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;
+ milestoneCount + "//" + votePartyCurrent + "//" + votePartyRequired;
}
}
@@ -1,485 +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(VotingPluginBungee bungee, 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) {
@Override
public void severe(String string) {
bungee.getLogger().severe(string);
}
@Override
public void debug(SQLException e) {
if (bungee.getConfig().getDebug()) {
e.printStackTrace();
}
}
};
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);
}
}
}
@@ -29,10 +29,34 @@ public class Config {
return getData().getStringList("BlockedServers");
}
public List<String> getWhiteListedServers() {
return getData().getStringList("WhiteListedServers");
}
public boolean getBroadcast() {
return getData().getBoolean("Broadcast", false);
}
public boolean getGeyserSupport() {
return getData().getBoolean("GeyserSupport", false);
}
public String getGeyserPrefix() {
return getData().getString("GeyserPrefix", ".");
}
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", "");
}
@@ -53,6 +77,34 @@ 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", "");
}
@@ -77,6 +129,34 @@ public class Config {
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();
@@ -7,6 +7,7 @@ import lombok.Getter;
import net.md_5.bungee.api.connection.ProxiedPlayer;
import net.md_5.bungee.config.Configuration;
import net.md_5.bungee.config.ConfigurationProvider;
import net.md_5.bungee.config.JsonConfiguration;
import net.md_5.bungee.config.YamlConfiguration;
public class NonVotedPlayersCache {
@@ -53,7 +54,8 @@ public class NonVotedPlayersCache {
bungee.getDataFolder().mkdir();
}
File file = new File(bungee.getDataFolder(), "nonvotedplayerscache.yml");
File yamlFile = new File(bungee.getDataFolder(), "nonvotedplayerscache.yml");
File file = new File(bungee.getDataFolder(), "nonvotedplayerscache.json");
if (!file.exists()) {
try {
@@ -62,9 +64,24 @@ public class NonVotedPlayersCache {
e.printStackTrace();
}
}
if (yamlFile.exists()) {
try {
data = ConfigurationProvider.getProvider(YamlConfiguration.class)
.load(new File(bungee.getDataFolder(), "nonvotedplayerscache.yml"));
yamlFile.renameTo(new File(bungee.getDataFolder(), "oldnonvotedplayerscache.yml"));
ConfigurationProvider.getProvider(YamlConfiguration.class).save(data,
new File(bungee.getDataFolder(), "oldnonvotedplayerscache.yml"));
} catch (IOException e) {
e.printStackTrace();
}
save();
}
try {
data = ConfigurationProvider.getProvider(YamlConfiguration.class)
.load(new File(bungee.getDataFolder(), "nonvotedplayerscache.yml"));
data = ConfigurationProvider.getProvider(JsonConfiguration.class)
.load(new File(bungee.getDataFolder(), "nonvotedplayerscache.json"));
} catch (IOException e) {
e.printStackTrace();
}
@@ -84,8 +101,8 @@ public class NonVotedPlayersCache {
public void save() {
try {
ConfigurationProvider.getProvider(YamlConfiguration.class).save(data,
new File(bungee.getDataFolder(), "nonvotedplayerscache.yml"));
ConfigurationProvider.getProvider(JsonConfiguration.class).save(data,
new File(bungee.getDataFolder(), "nonvotedplayerscache.json"));
} catch (IOException e) {
e.printStackTrace();
}
@@ -4,9 +4,12 @@ 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;
import net.md_5.bungee.config.JsonConfiguration;
import net.md_5.bungee.config.YamlConfiguration;
public class VoteCache {
@@ -18,6 +21,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 +53,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 +70,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 +94,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();
}
@@ -75,7 +115,9 @@ public class VoteCache {
bungee.getDataFolder().mkdir();
}
File file = new File(bungee.getDataFolder(), "votecache.yml");
File yamlFile = new File(bungee.getDataFolder(), "votecache.yml");
File file = new File(bungee.getDataFolder(), "votecache.json");
if (!file.exists()) {
try {
@@ -84,9 +126,23 @@ public class VoteCache {
e.printStackTrace();
}
}
if (yamlFile.exists()) {
try {
data = ConfigurationProvider.getProvider(YamlConfiguration.class)
.load(new File(bungee.getDataFolder(), "votecache.yml"));
yamlFile.renameTo(new File(bungee.getDataFolder(), "oldvotecache.yml"));
ConfigurationProvider.getProvider(YamlConfiguration.class).save(data,
new File(bungee.getDataFolder(), "oldvotecache.yml"));
} catch (IOException e) {
e.printStackTrace();
}
save();
}
try {
data = ConfigurationProvider.getProvider(YamlConfiguration.class)
.load(new File(bungee.getDataFolder(), "votecache.yml"));
data = ConfigurationProvider.getProvider(JsonConfiguration.class)
.load(new File(bungee.getDataFolder(), "votecache.json"));
} catch (IOException e) {
e.printStackTrace();
}
@@ -94,8 +150,8 @@ public class VoteCache {
public void save() {
try {
ConfigurationProvider.getProvider(YamlConfiguration.class).save(data,
new File(bungee.getDataFolder(), "votecache.yml"));
ConfigurationProvider.getProvider(JsonConfiguration.class).save(data,
new File(bungee.getDataFolder(), "votecache.json"));
} catch (IOException e) {
e.printStackTrace();
}
@@ -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;
@@ -18,18 +20,24 @@ public class VotingPluginBungeeCommand extends Command {
if (args.length > 0) {
if (args[0].equalsIgnoreCase("reload")) {
bungee.reload(false);
sender.sendMessage(new TextComponent("&aReloading VotingPluginBungee"));
sender.sendMessage(new TextComponent("Reloading VotingPluginBungee"));
}
if (args[0].equalsIgnoreCase("reloadmysql")) {
bungee.reload(true);
sender.sendMessage(new TextComponent("&aReloading VotingPluginBungee with MySQL"));
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);
sender.sendMessage(new TextComponent("&aSending vote"));
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")) {
@@ -46,17 +54,56 @@ public class VotingPluginBungeeCommand extends Command {
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[4];
TextComponent[] msg = new TextComponent[7];
msg[0] = new TextComponent("&avotingpluginbungee reload - Reload plugin");
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("&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;
}
}
}
@@ -1,483 +0,0 @@
package com.bencodez.votingplugin.bungee.velocity;
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;
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(VotingPluginVelocity plugin, String tableName, Config config) {
String tablePrefix = config.getString(config.getNode("Prefix"), "");
String hostName = config.getString(config.getNode("Host"), "");
int port = config.getInt(config.getNode("Port"), 0);
String user = config.getString(config.getNode("Username"), "");
String pass = config.getString(config.getNode("Password"), "");
String database = config.getString(config.getNode("Database"), "");
long lifeTime = config.getLong(config.getNode("MaxLifeTime"), -1);
int maxThreads = config.getInt(config.getNode("MaxConnections"), 1);
String str = config.getString(config.getNode("Line"), "");
if (maxThreads < 1) {
maxThreads = 1;
}
boolean useSSL = config.getBoolean(config.getNode("UseSSL"), false);
boolean publicKeyRetrieval = config.getBoolean(config.getNode("PublicKeyRetrieval"), false);
name = config.getString(config.getNode("Name"), "");
if (!name.isEmpty()) {
name = tableName;
}
if (tablePrefix != null) {
name = tablePrefix + tableName;
}
mysql = new com.bencodez.advancedcore.api.user.userstorage.mysql.api.MySQL(maxThreads) {
@Override
public void severe(String string) {
plugin.getLogger().error(string);
}
@Override
public void debug(SQLException e) {
if (plugin.getConfig().getDebug()) {
e.printStackTrace();
}
}
};
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);
}
}
}
@@ -5,6 +5,10 @@ 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 {
@@ -13,34 +17,46 @@ public class Config extends VelocityYMLFile {
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 getWaitForUserOnline() {
return getBoolean(getNode("WaitForUserOnline"), 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 boolean getAllowUnJoined() {
return getBoolean(getNode("AllowUnJoined"), false);
public String getBungeeMethod() {
return getString(getNode("BungeeMethod"), "PLUGINMESSAGING");
}
public String getBungeeHost() {
return getString(getNode("BungeeServer", "Host"), "");
}
public String getBungeeMethod() {
return getString(getNode("BungeeMethod"), "PLUGINMESSAGING");
}
public int getBungeePort() {
return getInt(getNode("BungeeServer", "Port"), 1297);
}
@@ -53,31 +69,96 @@ public class Config extends VelocityYMLFile {
return getString(getNode("FallBackServer"), "");
}
public boolean getSendVotesToAllServers() {
return getBoolean(getNode("SendVotesToAllServers"), true);
}
public ConfigurationNode getSpigotServerConfiguration(String s) {
return getNode("SpigotServers", s);
public ConfigurationNode getMysqlNode() {
return getNode("MySQL");
}
public int getPointsOnVote() {
return getInt(getNode("PointsOnVote"), 1);
}
public Collection<String> getSpigotServers() {
ArrayList<String> list = new ArrayList<String>();
for (ConfigurationNode conf : getNode("SpigotServers").getChildrenList()) {
list.add(conf.getKey().toString());
}
return list;
public boolean getSendVotesToAllServers() {
return getBoolean(getNode("SendVotesToAllServers"), true);
}
public ConfigurationNode getMysqlNode() {
return getNode("MySQL");
public boolean getVotePartyEnabled() {
return getBoolean(getVotePartyNode().getNode("Enabled"), false);
}
public long getLong(ConfigurationNode node, long def) {
return node.getLong(def);
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);
}
}
@@ -2,9 +2,10 @@ package com.bencodez.votingplugin.bungee.velocity;
import java.io.File;
import com.bencodez.advancedcore.bungeeapi.velocity.VelocityJSONFile;
import com.velocitypowered.api.proxy.Player;
public class NonVotedPlayersCache extends VelocityYMLFile {
public class NonVotedPlayersCache extends VelocityJSONFile {
private VotingPluginVelocity plugin;
@@ -1,98 +0,0 @@
package com.bencodez.votingplugin.bungee.velocity;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import com.google.common.reflect.TypeToken;
import lombok.Getter;
import ninja.leaping.configurate.ConfigurationNode;
import ninja.leaping.configurate.objectmapping.ObjectMappingException;
import ninja.leaping.configurate.yaml.YAMLConfigurationLoader;
public class VelocityYMLFile {
@Getter
private File file;
@Getter
private ConfigurationNode conf;
private YAMLConfigurationLoader loader;
public VelocityYMLFile(File file) {
this.file = file;
if (!file.exists()) {
try {
file.getParentFile().mkdirs();
file.createNewFile();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
loader = YAMLConfigurationLoader.builder().setPath(file.toPath()).build();
try {
conf = loader.load();
} catch (IOException e) {
e.printStackTrace();
}
}
public ConfigurationNode getData() {
return conf;
}
public ConfigurationNode getNode(Object... path) {
return getData().getNode(path);
}
public List<String> getStringList(ConfigurationNode node, ArrayList<String> def) {
try {
return node.getList(TypeToken.of(String.class), def);
} catch (ObjectMappingException e) {
e.printStackTrace();
return def;
}
}
public String getString(ConfigurationNode node, String def) {
return node.getString(def);
}
public boolean getBoolean(ConfigurationNode node, boolean def) {
return node.getBoolean(def);
}
public int getInt(ConfigurationNode node, int def) {
return node.getInt(def);
}
public ArrayList<String> getKeys(ConfigurationNode node) {
ArrayList<String> keys = new ArrayList<String>();
for (ConfigurationNode key : node.getChildrenList()) {
keys.add(key.getKey().toString());
}
return keys;
}
public void reload() {
loader = YAMLConfigurationLoader.builder().setPath(file.toPath()).build();
try {
conf = loader.load();
} catch (IOException e) {
e.printStackTrace();
}
}
public void save() {
try {
loader.save(conf);
} catch (IOException e) {
e.printStackTrace();
}
}
}
@@ -3,16 +3,42 @@ package com.bencodez.votingplugin.bungee.velocity;
import java.io.File;
import java.util.Collection;
import com.bencodez.advancedcore.bungeeapi.velocity.VelocityJSONFile;
import com.bencodez.votingplugin.bungee.OfflineBungeeVote;
import com.bencodez.votingplugin.timequeue.VoteTimeQueue;
import ninja.leaping.configurate.ConfigurationNode;
public class VoteCache extends VelocityYMLFile {
public class VoteCache extends VelocityJSONFile {
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 };
@@ -22,8 +48,13 @@ public class VoteCache extends VelocityYMLFile {
getNode(path, "Time").setValue(voteData.getTime());
getNode(path, "Real").setValue(voteData.isRealVote());
getNode(path, "Text").setValue(voteData.getText());
}
save();
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) {
@@ -35,8 +66,6 @@ public class VoteCache extends VelocityYMLFile {
getNode(path, "Time").setValue(voteData.getTime());
getNode(path, "Real").setValue(voteData.isRealVote());
getNode(path, "Text").setValue(voteData.getText());
save();
}
public void clearData() {
@@ -49,6 +78,10 @@ public class VoteCache extends VelocityYMLFile {
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);
}
@@ -61,6 +94,10 @@ public class VoteCache extends VelocityYMLFile {
return getKeys(getNode("VoteCache"));
}
public Collection<String> getTimedVoteCache() {
return getKeys(getNode("TimedVoteCache"));
}
public Collection<String> getServerVotes(String server) {
return getKeys(getNode("OnlineCache", server));
}
@@ -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);
}
});
}
}
File diff suppressed because it is too large. Load diff
@@ -1,5 +1,6 @@
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;
@@ -33,10 +34,16 @@ public class VotingPluginVelocityCommand implements SimpleCommand {
if (args.length >= 2) {
String user = args[1];
String site = args[2];
plugin.vote(user, site, false);
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(
@@ -53,17 +60,55 @@ public class VotingPluginVelocityCommand implements SimpleCommand {
.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[4];
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;
}
}
File diff suppressed because it is too large. Load diff
@@ -21,7 +21,6 @@ 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;
@@ -66,6 +65,7 @@ public class AdminGUI {
plugin.getConfigVoteSites().generateVoteSite(value);
player.sendMessage("Generated site");
plugin.reload();
openAdminGUIVoteSiteSite(player, plugin.getVoteSite(value, true));
}
});
} else {
@@ -110,7 +110,7 @@ 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")) {
@@ -118,7 +118,7 @@ public class AdminGUI {
@Override
public void onClick(ClickEvent clickEvent) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(),
RewardHandler.getInstance().getDirectlyDefined("FirstVoteToday"));
plugin.getRewardHandler().getDirectlyDefined("FirstVoteToday"));
}
});
@@ -127,7 +127,16 @@ 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"));
}
});
@@ -136,7 +145,7 @@ public class AdminGUI {
@Override
public void onClick(ClickEvent clickEvent) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(),
RewardHandler.getInstance().getDirectlyDefined("AnySiteRewards"));
plugin.getRewardHandler().getDirectlyDefined("AnySiteRewards"));
}
});
@@ -145,7 +154,16 @@ public class AdminGUI {
@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"));
}
});
@@ -165,6 +183,17 @@ public class AdminGUI {
}
});
buttons.add(new BInventoryButton(
new ItemBuilder(Material.STONE, 1).setName("&cBackground task time").addLoreLine("&aClick to see")) {
@Override
public void onClick(ClickEvent event) {
event.getPlayer().sendMessage("Last background task time: " + plugin.getLastBackgroundTaskTimeTaken());
}
});
return buttons;
}
@@ -233,7 +262,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)
@@ -355,12 +390,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);
}
}
@@ -18,7 +18,7 @@ public class AdminVoteBungeeSettings extends GUIHandler {
private VotingPluginMain plugin;
public AdminVoteBungeeSettings(VotingPluginMain plugin, CommandSender player) {
super(player);
super(plugin, player);
this.plugin = plugin;
}
@@ -95,6 +95,15 @@ public class AdminVoteBungeeSettings extends GUIHandler {
}
}));
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()) {
@@ -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;
}
@@ -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;
}
@@ -38,14 +38,14 @@ public class AdminVotePlaceholders extends GUIHandler {
for (PlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getPlaceholders()) {
String msg = "";
String identifier = placeholder.getIdentifier();
String identifier = placeholder.getIdentifier().toLowerCase();
if (identifier.endsWith("_")) {
identifier += "#";
}
if (placeholder.hasDescription()) {
msg = "VotingPlugin_" + identifier + " - " + placeholder.getDescription();
msg = "votingplugin_" + identifier + " - " + placeholder.getDescription();
} else {
msg = "VotingPlugin_" + identifier + "";
msg = "votingplugin_" + identifier + "";
}
Layout layout = new Layout(new ArrayList<String>(Arrays.asList("[Json]")));
@@ -54,16 +54,16 @@ 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();
String identifier = placeholder.getIdentifier().toLowerCase();
if (identifier.endsWith("_")) {
identifier += "#";
}
if (placeholder.hasDescription()) {
msg = "VotingPlugin_" + identifier + " - " + placeholder.getDescription();
msg = "votingplugin_" + identifier + " - " + placeholder.getDescription();
} else {
msg = "VotingPlugin_" + identifier + "";
msg = "votingplugin_" + identifier + "";
}
Layout layout = new Layout(new ArrayList<String>(Arrays.asList("[Json]")));
@@ -82,26 +82,26 @@ public class AdminVotePlaceholders extends GUIHandler {
ArrayList<String> msg = new ArrayList<String>();
msg.add("&cPlaceholders:");
for (PlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getPlaceholders()) {
String identifier = placeholder.getIdentifier();
String identifier = placeholder.getIdentifier().toLowerCase();
if (identifier.endsWith("_")) {
identifier += "#";
}
if (placeholder.hasDescription()) {
msg.add("VotingPlugin_" + identifier + " - " + placeholder.getDescription());
msg.add("votingplugin_" + identifier + " - " + placeholder.getDescription());
} else {
msg.add("VotingPlugin_" + identifier + "");
msg.add("votingplugin_" + identifier + "");
}
}
for (PlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getNonPlayerPlaceholders()) {
String identifier = placeholder.getIdentifier();
for (NonPlayerPlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getNonPlayerPlaceholders()) {
String identifier = placeholder.getIdentifier().toLowerCase();
if (identifier.endsWith("_")) {
identifier += "#";
}
if (placeholder.hasDescription()) {
msg.add("VotingPlugin_" + identifier + " - " + placeholder.getDescription());
msg.add("votingplugin_" + identifier + " - " + placeholder.getDescription());
} else {
msg.add("VotingPlugin_" + identifier + "");
msg.add("votingplugin_" + identifier + "");
}
}
@@ -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;
}
@@ -40,11 +40,11 @@ public class AdminVotePlaceholdersPlayer extends GUIHandler {
BookWrapper book = new BookWrapper("Placeholders");
for (PlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getPlaceholders()) {
String identifier = placeholder.getIdentifier();
String identifier = placeholder.getIdentifier().toLowerCase();
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();
String identifier = placeholder.getIdentifier().toLowerCase();
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]")));
@@ -78,22 +78,20 @@ public class AdminVotePlaceholdersPlayer extends GUIHandler {
placeholderUser = UserManager.getInstance().getVotingPluginUser(user.getPrimaryAccount());
}
for (PlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getPlaceholders()) {
String identifier = placeholder.getIdentifier();
String identifier = placeholder.getIdentifier().toLowerCase();
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()) {
String identifier = placeholder.getIdentifier();
for (NonPlayerPlaceHolder<VotingPluginUser> placeholder : plugin.getPlaceholders().getNonPlayerPlaceholders()) {
String identifier = placeholder.getIdentifier().toLowerCase();
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;
}
@@ -93,7 +92,7 @@ public class AdminVoteVoteParty extends GUIHandler {
}, new Number[] { 0, 10, 50, 100 })
.currentValue("" + plugin.getServerData().getVotePartyExtraRequired()).allowCustomOption(true)
.request(clickEvent.getPlayer());
;
}
});
@@ -197,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) {
@@ -212,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"));
}
});
@@ -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;
}
@@ -68,12 +67,12 @@ public class AdminVoteCumulative extends GUIHandler {
@Override
public void onInput(Player player, Number value) {
RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(),
RewardHandler.getInstance()
plugin.getRewardHandler()
.getDirectlyDefined("Cumulative." + value.intValue() + ".Rewards"));
}
}, options).allowCustomOption(false).usingMethod(InputMethod.INVENTORY)
.request(clickEvent.getPlayer());
;
}
});
@@ -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;
}
@@ -62,7 +62,7 @@ public class AdminVoteCumulativeRemove extends GUIHandler {
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;
}
@@ -62,7 +62,7 @@ public class AdminVoteMilestoneRemove extends GUIHandler {
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,12 +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());
;
}
});
@@ -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;
}
@@ -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.command.gui.RewardEditGUI;
import com.bencodez.votingplugin.VotingPluginMain;
@@ -27,7 +26,7 @@ public class AdminVoteVoteShopItem extends GUIHandler {
private VotingPluginMain plugin;
public AdminVoteVoteShopItem(VotingPluginMain plugin, CommandSender player, String identifier) {
super(player);
super(plugin, player);
this.plugin = plugin;
this.identifier = identifier;
}
@@ -86,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
@@ -115,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"));
}
});
@@ -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;
}
@@ -64,7 +64,7 @@ public class AdminVoteVoteShopItemRemove extends GUIHandler {
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;
}
@@ -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,26 @@ 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 + "."
+ clickEvent.getButton().getLastRewardsPath(player))
.setGiveOffline(false).send(clickEvent.getPlayer());
}
});
}
inv.openInventory(player);
}
@@ -9,13 +9,14 @@ import com.bencodez.advancedcore.api.gui.GUIHandler;
import com.bencodez.advancedcore.api.gui.GUIMethod;
import com.bencodez.advancedcore.api.inventory.BInventory;
import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent;
import com.bencodez.advancedcore.api.inventory.BInventoryButton;
import com.bencodez.advancedcore.api.inventory.UpdatingBInventoryButton;
import com.bencodez.advancedcore.api.item.ItemBuilder;
import com.bencodez.advancedcore.api.messages.StringParser;
import com.bencodez.advancedcore.api.misc.ArrayUtils;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import com.bencodez.advancedcore.api.rewards.RewardBuilder;
import com.bencodez.advancedcore.api.rewards.RewardOptions;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.topvoter.TopVoter;
import com.bencodez.votingplugin.user.UserManager;
import com.bencodez.votingplugin.user.VotingPluginUser;
@@ -25,7 +26,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;
}
@@ -43,15 +44,15 @@ public class VoteGUI extends GUIHandler {
String str = plugin.getConfigFile().getVoteTopDefault();
if (lore.length == 0) {
if (slot.equalsIgnoreCase("url")) {
if (StringParser.getInstance().startsWithIgnoreCase(slot, "url")) {
lore = new String[] { "&aClick me" };
} else if (slot.equalsIgnoreCase("next")) {
} else if (StringParser.getInstance().startsWithIgnoreCase(slot, "next")) {
lore = ArrayUtils.getInstance().convert(new VoteNext(plugin, player, user).getChat(player));
} else if (slot.equalsIgnoreCase("last")) {
} else if (StringParser.getInstance().startsWithIgnoreCase(slot, "last")) {
lore = ArrayUtils.getInstance().convert(new VoteLast(plugin, player, user).getChat(player));
} else if (slot.equalsIgnoreCase("total")) {
} else if (StringParser.getInstance().startsWithIgnoreCase(slot, "total")) {
lore = ArrayUtils.getInstance().convert(new VoteTotal(plugin, player, user).getChat(player));
} else if (slot.equalsIgnoreCase("top")) {
} else if (StringParser.getInstance().startsWithIgnoreCase(slot, "top")) {
if (str.equalsIgnoreCase("monthly")) {
lore = plugin.getTopVoterHandler().topVoterMonthly(1);
@@ -128,14 +129,21 @@ public class VoteGUI extends GUIHandler {
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());
inv.addPlaceholder("sitesavailable", "" + user.getSitesNotVotedOn());
for (String slot : plugin.getGui().getChestVoteGUISlots()) {
for (final String slot : plugin.getGui().getChestVoteGUISlots()) {
ItemBuilder builder = getItemSlot(slot, player);
inv.addButton(new UpdatingBInventoryButton(builder, 1000, 1000) {
inv.addButton(new UpdatingBInventoryButton(plugin, builder, 1000, 1000) {
@Override
public void onClick(ClickEvent event) {
@@ -153,31 +161,15 @@ public class VoteGUI extends GUIHandler {
}
});
} else {
if (slot.equalsIgnoreCase("url")) {
new VoteURL(plugin, player, user, true).open();
} else if (slot.equalsIgnoreCase("next")) {
new VoteNext(plugin, player, user).open(GUIMethod.CHEST);
} else if (slot.equalsIgnoreCase("last")) {
new VoteLast(plugin, player, user).open(GUIMethod.CHEST);
} else if (slot.equalsIgnoreCase("total")) {
new VoteTotal(plugin, player, user).open(GUIMethod.CHEST);
} else if (slot.equalsIgnoreCase("top")) {
new VoteTopVoter(plugin, player, user, TopVoter.getDefault(), 1).open(GUIMethod.CHEST);
} else if (slot.equalsIgnoreCase("today")) {
new VoteToday(plugin, player, user, 1).open(GUIMethod.CHEST);
} else if (slot.equalsIgnoreCase("help")) {
player.performCommand("vote help");
} else if (slot.equalsIgnoreCase("shop")) {
new VoteShop(plugin, player, user).open(GUIMethod.CHEST);
} else if (slot.equalsIgnoreCase("lastmonth")) {
new VoteTopVoterLastMonth(plugin, player, user).open(GUIMethod.CHEST);
}
plugin.getCommandLoader().processSlotClick(player, user, slot);
}
if (RewardHandler.getInstance().hasRewards(plugin.getGui().getData(),
plugin.getGui().getChestVoteGUISlotRewardsPath(slot))) {
RewardHandler.getInstance().giveReward(UserManager.getInstance().getVotingPluginUser(player),
plugin.getGui().getData(), plugin.getGui().getChestVoteGUISlotRewardsPath(slot),
if (plugin.getRewardHandler().hasRewards(plugin.getGui().getData(), plugin.getGui()
.getChestVoteGUISlotRewardsPath(slot, event.getButton().getLastRewardsPath(player)))) {
plugin.getRewardHandler().giveReward(UserManager.getInstance().getVotingPluginUser(player),
plugin.getGui().getData(),
plugin.getGui().getChestVoteGUISlotRewardsPath(slot,
event.getButton().getLastRewardsPath(player)),
new RewardOptions().addPlaceholder("identifier", slot));
}
}
@@ -189,12 +181,29 @@ public class VoteGUI extends GUIHandler {
item.addPlaceholder("points", "" + user.getPoints());
item.addPlaceholder("player", user.getPlayerName());
item.addPlaceholder("top", plugin.getConfigFile().getVoteTopDefault());
item.addPlaceholder("sitesavailable", "" + user.getSitesNotVotedOn());
return item;
}
});
}
String guiPath = "VoteGUI";
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 + "."
+ clickEvent.getButton().getLastRewardsPath(player))
.setGiveOffline(false).send(clickEvent.getPlayer());
}
});
}
inv.openInventory(player);
}
@@ -11,6 +11,7 @@ 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;
@@ -22,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;
}
@@ -63,6 +64,28 @@ public class VoteHelp extends GUIHandler {
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());
Collections.sort(unsortedList, String.CASE_INSENSITIVE_ORDER);
for (String cmd : unsortedList) {
msg.add(unsorted.get(cmd));
}
return msg;
}
@Override
public void onBook(Player player) {
@@ -86,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;
}
@@ -63,12 +66,28 @@ public class VoteLast extends GUIHandler {
for (VoteSite site : plugin.getVoteSites()) {
if (!site.isHidden()) {
inv.addButton(inv.getNextSlot(),
new UpdatingBInventoryButton(site.getItem().setName(site.getDisplayName())
new UpdatingBInventoryButton(plugin, site.getItem().setName(site.getDisplayName())
.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
@@ -80,6 +99,22 @@ public class VoteLast extends GUIHandler {
}
}
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 + "."
+ clickEvent.getButton().getLastRewardsPath(player))
.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,46 @@ 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) {
@Override
public void onClick(ClickEvent clickEvent) {
if (!site.isHidden()) {
String siteNameDisplay = plugin.getGui().getChestVoteNextCustomSiteNamesDisplays(site.getKey());
if (siteNameDisplay.isEmpty()) {
siteNameDisplay = site.getDisplayName();
}
inv.addButton(inv.getNextSlot(),
new UpdatingBInventoryButton(plugin, site.getItem().setName(siteNameDisplay)
.setLore(StringParser.getInstance().replacePlaceHolder(
plugin.getGui().getChestVoteNextLine(), "time", user.voteCommandNextInfo(site)))
.setAmountNone(1), 1000, 1000) {
@Override
public ItemBuilder onUpdate(Player player) {
return site.getItem().setName(site.getDisplayName()).setLore(user.voteCommandNextInfo(site))
.setAmountNone(1).addPlaceholder("player", user.getPlayerName());
}
});
@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());
}
});
}
}
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 + "."
+ clickEvent.getButton().getLastRewardsPath(player))
.setGiveOffline(false).send(clickEvent.getPlayer());
}
});
}
if (plugin.getGui().getChestVoteNextBackButton()) {
@@ -13,7 +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.messages.StringParser;
import com.bencodez.advancedcore.api.rewards.RewardHandler;
import com.bencodez.advancedcore.api.rewards.RewardBuilder;
import com.bencodez.advancedcore.api.rewards.RewardOptions;
import com.bencodez.votingplugin.VotingPluginMain;
import com.bencodez.votingplugin.user.UserManager;
@@ -25,7 +25,7 @@ public class VoteShop extends GUIHandler {
private VotingPluginUser user;
public VoteShop(VotingPluginMain plugin, CommandSender player, VotingPluginUser user) {
super(player);
super(plugin, player);
this.plugin = plugin;
this.user = user;
}
@@ -51,7 +51,12 @@ 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.addPlaceholder("sitesavailable", "" + user.getSitesNotVotedOn());
inv.dontClose();
for (final String identifier : plugin.getGui().getChestShopIdentifiers()) {
@@ -61,14 +66,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,17 +93,15 @@ 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.cache();
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);
}
// if (plugin.getGui().getChestVoteShopCloseGUI(identifier)) {
// event.closeInventory();
// }
// limit fail-safe, should never be needed, except in rare cases
boolean limitPass = true;
@@ -113,8 +119,10 @@ 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));
@@ -131,11 +139,12 @@ public class VoteShop extends GUIHandler {
}
} else {
new VoteShopConfirm(plugin, player, user, identifier).open(GUIMethod.CHEST);
;
}
} else {
user.sendMessage(plugin.getGui().getChestVoteShopLimitReached());
}
plugin.getCommandLoader().processSlotClick(player, user, identifier);
}
}
@@ -148,14 +157,27 @@ public class VoteShop extends GUIHandler {
@Override
public void onClick(ClickEvent event) {
user.sendMessage(plugin.getConfigFile().getFormatShopNotPurchasable());
}
}.dontClose().addData("identifier", identifier).addData("Limit", limit));
}.addData("identifier", identifier).addData("Limit", limit));
}
}
}
for (final String str : plugin.getGui().getChestGUIVoteShopExtraItems()) {
inv.addButton(new BInventoryButton(new ItemBuilder(plugin.getGui().getChestGUIVoteShopExtraItems(str))) {
@Override
public void onClick(ClickEvent clickEvent) {
plugin.getCommandLoader().processSlotClick(player, user, str);
new RewardBuilder(plugin.getGui().getData(),
"CHEST.VoteShopExtraItems." + str + "." + clickEvent.getButton().getLastRewardsPath(player))
.setGiveOffline(false).send(clickEvent.getPlayer());
}
});
}
if (plugin.getGui().getChestVoteShopBackButton()) {
inv.addButton(plugin.getCommandLoader().getBackButton(user));
}
@@ -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.cache();
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;
}
@@ -119,6 +120,22 @@ 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 + "."
+ clickEvent.getButton().getLastRewardsPath(player))
.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;
@@ -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,34 @@ 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 + "."
+ clickEvent.getButton().getLastRewardsPath(player))
.setGiveOffline(false).send(clickEvent.getPlayer());
}
});
}
if (plugin.getGui().getChestVoteTodayBackButton()) {
inv.addButton(plugin.getCommandLoader().getBackButton(user));
@@ -129,7 +147,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 +168,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;
@@ -2,11 +2,15 @@ package com.bencodez.votingplugin.commands.gui.player;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map.Entry;
import java.util.Queue;
import java.util.Set;
import java.util.concurrent.ConcurrentLinkedQueue;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.ClickType;
@@ -17,8 +21,10 @@ 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.topvoter.TopVoter;
import com.bencodez.votingplugin.topvoter.TopVoterPlayer;
import com.bencodez.votingplugin.user.VotingPluginUser;
public class VoteTopVoter extends GUIHandler {
@@ -29,7 +35,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,14 +75,23 @@ 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();
ConfigurationSection customization = plugin.getGui().getChestVoteTopCustomization();
boolean customzationEnabled = false;
Queue<Integer> playerSlots = new ConcurrentLinkedQueue<Integer>();
if (customization != null) {
customzationEnabled = customization.getBoolean("Enabled");
List<Integer> customizationPlayerSlots = customization.getIntegerList("PlayerSlots");
playerSlots.addAll(customizationPlayerSlots);
}
BInventory inv = new BInventory(plugin.getGui().getChestVoteTopName());
inv.addPlaceholder("topvoter", topVoter);
if (!plugin.getConfigFile().isAlwaysCloseInventory()) {
@@ -84,8 +99,9 @@ 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());
@@ -95,7 +111,8 @@ public class VoteTopVoter extends GUIHandler {
playerItem.setLore(new ArrayList<String>());
inv.addButton(new BInventoryButton(playerItem.setName(plugin.getGui().getChestVoteTopItemName())
BInventoryButton button = new BInventoryButton(playerItem
.setName(plugin.getGui().getChestVoteTopItemName())
.addLoreLine(plugin.getGui().getChestVoteTopItemLore()).addPlaceholder("position", "" + pos)
.addPlaceholder("player", entry.getKey().getPlayerName())
.addPlaceholder("votes", "" + entry.getValue())) {
@@ -103,36 +120,88 @@ 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());
}
}
}.addData("player", entry.getKey().getPlayerName()).addData("User", entry.getKey()));
}.addData("player", entry.getKey().getPlayerName()).addData("User", entry.getKey());
if (customzationEnabled && !playerSlots.isEmpty()) {
button.setSlot(playerSlots.remove());
}
inv.setCloseInv(plugin.getGui().getChestVoteTopCloseGUIOnClick());
inv.addButton(button);
pos++;
}
final TopVoter cur = top;
inv.getPageButtons().add(new BInventoryButton(
new ItemBuilder(plugin.getGui().getChestVoteTopSwitchItem()).addPlaceholder("Top", topVoter)) {
@Override
public void onClick(ClickEvent clickEvent) {
if (!clickEvent.getClick().equals(ClickType.RIGHT)) {
new VoteTopVoter(plugin, player, user, cur.next(), 0).open(GUIMethod.CHEST);
} else {
new VoteTopVoter(plugin, player, user, cur.prev(), 0).open(GUIMethod.CHEST);
}
TopVoter newTops = top;
ArrayList<String> tops = plugin.getGui().getChestVoteTopSwitchItemTopVoters();
if (!tops.isEmpty()) {
for (String name : tops) {
newTops.getSwitchItems().add(TopVoter.getTopVoter(name));
}
});
if (plugin.getGui().getChestVoteTopBackButton()) {
inv.getPageButtons().add(plugin.getCommandLoader().getBackButton(user).setSlot(1));
}
inv.setPages(true);
final TopVoter cur = newTops;
if (!customzationEnabled) {
inv.getPageButtons().add(new BInventoryButton(
new ItemBuilder(plugin.getGui().getChestVoteTopSwitchItem()).addPlaceholder("Top", topVoter)) {
@Override
public void onClick(ClickEvent clickEvent) {
if (!clickEvent.getClick().equals(ClickType.RIGHT)) {
new VoteTopVoter(plugin, player, user, cur.next(), 0).open(GUIMethod.CHEST);
} else {
new VoteTopVoter(plugin, player, user, cur.prev(), 0).open(GUIMethod.CHEST);
}
}
});
} else {
inv.addButton(new BInventoryButton(
new ItemBuilder(plugin.getGui().getChestVoteTopSwitchItem()).addPlaceholder("Top", topVoter)) {
@Override
public void onClick(ClickEvent clickEvent) {
if (!clickEvent.getClick().equals(ClickType.RIGHT)) {
new VoteTopVoter(plugin, player, user, cur.next(), 0).open(GUIMethod.CHEST);
} else {
new VoteTopVoter(plugin, player, user, cur.prev(), 0).open(GUIMethod.CHEST);
}
}
});
}
if (plugin.getGui().getChestVoteTopBackButton()) {
if (customzationEnabled) {
inv.addButton(plugin.getCommandLoader().getBackButton(user)
.setSlot(customization.getInt("BackButtonSlot", 0)));
} else {
inv.getPageButtons().add(plugin.getCommandLoader().getBackButton(user).setSlot(1));
}
}
String guiPath = "VoteTop.Customization";
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) {
plugin.getCommandLoader().processSlotClick(player, user, str);
new RewardBuilder(plugin.getGui().getData(),
"CHEST." + guiPath + ".ExtraItems." + str + ".Rewards").setGiveOffline(false)
.send(clickEvent.getPlayer());
}
});
}
if (customization == null || (customzationEnabled && !customization.getBoolean("RemoveBottomBar"))) {
inv.setPages(true);
}
inv.setMaxInvSize(plugin.getGui().getChestVoteTopSize());
inv.openInventory(player);
} catch (Exception e) {
@@ -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;
}
@@ -66,7 +67,7 @@ public class VoteTotal extends GUIHandler {
inv.addPlaceholder("player", user.getPlayerName());
for (final TopVoter top : TopVoter.values()) {
inv.addButton(new UpdatingBInventoryButton(
inv.addButton(new UpdatingBInventoryButton(plugin,
new ItemBuilder(plugin.getGui().getChestVoteTotalItem(top))
.addPlaceholder("Total", "" + user.getTotal(top)).addPlaceholder("topvoter", top.getName()),
1000, 1000) {
@@ -85,6 +86,22 @@ 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 + "."
+ clickEvent.getButton().getLastRewardsPath(player))
.setGiveOffline(false).send(clickEvent.getPlayer());
}
});
}
if (plugin.getGui().getChestVoteTotalBackButton()) {
inv.addButton(plugin.getCommandLoader().getBackButton(user));
}
@@ -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;
@@ -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(plugin, 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(plugin, builder, 5000, 5000) {
@Override
public void onClick(ClickEvent event) {
@@ -221,9 +221,10 @@ public class VoteURL extends GUIHandler {
@Override
public void onClick(ClickEvent clickEvent) {
new RewardBuilder(plugin.getGui().getData(), "CHEST.VoteURL.ExtraItems." + str + ".Rewards")
new RewardBuilder(plugin.getGui().getData(),
"CHEST.VoteURL.ExtraItems." + str + "." + clickEvent.getButton().getLastRewardsPath(player))
.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);
@@ -69,7 +69,7 @@ public class VoteURLVoteSite extends GUIHandler {
}
});
inv.addButton(new UpdatingBInventoryButton(
inv.addButton(new UpdatingBInventoryButton(plugin,
new ItemBuilder(Material.COMPASS).setName("&4Next Vote").addLoreLine(user.voteCommandNextInfo(site)),
1000, 1000) {
@@ -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;
@@ -41,6 +43,10 @@ public class BungeeSettings extends YMLFile {
@Getter
private boolean perServerPoints = false;
@ConfigDataBoolean(path = "PerServerMilestones")
@Getter
private boolean perServerMilestones = false;
@ConfigDataBoolean(path = "PerServerRewards")
@Getter
private boolean perServerRewards = false;
@@ -52,10 +58,6 @@ public class BungeeSettings extends YMLFile {
@ConfigDataString(path = "Server")
@Getter
private String server = "PleaseSet";
public String getServerNameStorage() {
return getServer().replace("-", "_");
}
@ConfigDataString(path = "SpigotServer.Host")
@Getter
@@ -77,10 +79,30 @@ public class BungeeSettings extends YMLFile {
@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,10 +34,22 @@ 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 = "PreloadSkulls")
@Getter
private boolean preloadSkulls = false;
@ConfigDataBoolean(path = "AllowUnJoinedCheckServer")
@Getter
private boolean allowUnJoinedCheckServer = true;
@@ -45,10 +58,6 @@ public class Config extends YMLFile {
@Getter
private boolean allowVotePointTransfers = false;
@ConfigDataBoolean(path = "AlterColumns")
@Getter
private boolean alterColumns = true;
@ConfigDataBoolean(path = "AlternateUUIDLookup")
@Getter
private boolean alternateUUIDLookup = false;
@@ -61,10 +70,6 @@ public class Config extends YMLFile {
@Getter
private boolean alwaysUpdate = false;
@ConfigDataBoolean(path = "AlwaysWaitForCachePlaceholders")
@Getter
private boolean alwaysWaitForCachePlaceholders = false;
@ConfigDataBoolean(path = "AutoCreateVoteSites")
@Getter
private boolean autoCreateVoteSites = true;
@@ -73,26 +78,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 = 150;
@ConfigDataInt(path = "ConvertDelay", defaultValue = 30000)
@Getter
private int convertDelay;
@ConfigDataBoolean(path = "CountFakeVotes")
@Getter
private boolean countFakeVotes = true;
@@ -101,10 +86,6 @@ public class Config extends YMLFile {
@Getter
private int delayBetweenUpdates = 3;
@ConfigDataInt(path = "DelayLoginEvent")
@Getter
private int delayLoginEvent = 0;
@ConfigDataBoolean(path = "DisableAdvancedTab")
@Getter
private boolean disableAdvancedTab = false;
@@ -121,6 +102,10 @@ 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;
@@ -137,6 +122,10 @@ public class Config extends YMLFile {
@Getter
private boolean extraAllSitesCheck = false;
@ConfigDataBoolean(path = "CloseInventoryOnVote")
@Getter
private boolean closeInventoryOnVote = true;
@ConfigDataBoolean(path = "ExtraBackgroundUpdate")
@Getter
private boolean extraBackgroundUpdate = false;
@@ -153,6 +142,14 @@ 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;
@@ -190,6 +187,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;
@@ -239,7 +244,7 @@ public class Config extends YMLFile {
@ConfigDataInt(path = "MaxiumNumberOfTopVotersToLoad")
@Getter
private int MaxiumNumberOfTopVotersToLoad = -1;
private int MaxiumNumberOfTopVotersToLoad = 1000;
@ConfigDataBoolean(path = "OverrideVersionDisable")
@Getter
@@ -299,6 +304,26 @@ public class Config extends YMLFile {
return str;
}
public Set<String> getCustomPlaceholderReturns() {
Set<String> str = getData().getConfigurationSection("CustomPlaceholderReturns").getKeys(false);
if (str == null) {
str = new HashSet<String>();
}
return str;
}
public Set<String> getCustomPlaceholderReturns(String placeholder) {
Set<String> str = getData().getConfigurationSection("CustomPlaceholderReturns." + placeholder).getKeys(false);
if (str == null) {
str = new HashSet<String>();
}
return str;
}
public String getCustomPlaceholderReturns(String placeholder, String returnString) {
return getData().getString("CustomPlaceholderReturns." + placeholder + "." + returnString, "");
}
public ConfigurationSection getCustomCommands(String ident) {
return getData().getConfigurationSection("CustomCommands." + ident);
}
@@ -341,6 +366,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.
*
@@ -349,10 +378,6 @@ public class Config extends YMLFile {
public String getFormatCommandsVoteHelpLine() {
return getData().getString("Format.Commands.Vote.Help.Line", "&6%Command% - &6%HelpMessage%");
}
public String getFormatCommandsVoteHelpHoverColor() {
return getData().getString("Format.Commands.Vote.Help.HoverColor", "AQUA");
}
/**
* Gets the commands vote help require permission.
@@ -416,6 +441,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.
*
@@ -558,10 +587,11 @@ public class Config extends YMLFile {
}
public String getFormatShopFailedMsg() {
String msg = getData().getString("Format.ShopFailed", "&cYou do not have %Points% points to purhcase this!");
return msg;
return getData().getString("Format.ShopFailed", "&cYou do not have %Points% points to purhcase this!");
}
public String getFormatShopNotPurchasable() {
return getData().getString("Format.ShopNotPurchasable", "&cThis item is not buyable!");
}
public String getFormatShopPurchaseMsg() {
@@ -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);
}
/**
@@ -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,6 +146,10 @@ public class GUI extends YMLFile {
@Getter
private boolean lastMonthGUI = false;
@ConfigDataBoolean(path = "CHEST.VoteLast.ClickableLinks")
@Getter
private boolean chestVoteLastClickableLinks = true;
private VotingPluginMain plugin;
public GUI(VotingPluginMain plugin) {
@@ -183,7 +191,6 @@ public class GUI extends YMLFile {
public String getChestShopIdentifierRewardsPath(String identifier) {
return "CHEST.Shop." + identifier + ".Rewards";
}
public Set<String> getChestShopIdentifiers() {
@@ -240,8 +247,8 @@ 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";
public String getChestVoteGUISlotRewardsPath(String slot, String lastPath) {
return "CHEST.VoteGUI." + slot + "." + lastPath;
}
/**
@@ -261,6 +268,10 @@ public class GUI extends YMLFile {
return getData().getConfigurationSection("CHEST.VoteGUI." + slot + ".Item");
}
public ConfigurationSection getChestVoteTopCustomization() {
return getData().getConfigurationSection("CHEST.VoteTop.Customization");
}
/**
* Gets the vote GUI slot slot.
*
@@ -290,6 +301,14 @@ public class GUI extends YMLFile {
public String getChestVoteNextName() {
return getData().getString("CHEST.VoteNext.Name", "VoteNext: %player%");
}
public String getChestVoteNextLine() {
return getData().getString("CHEST.VoteNext.Line", "%time%");
}
public String getChestVoteNextCustomSiteNamesDisplays(String site) {
return getData().getString("CHEST.VoteNext.CustomSiteNamesDisplays." + site, "");
}
public String getChestVoteRewardName() {
return getData().getString("CHEST.VoteRewardName", "VoteReward");
@@ -396,6 +415,10 @@ public class GUI extends YMLFile {
return getData().getBoolean("CHEST.VoteTop.OpenMainGUIOnClick", true);
}
public boolean getChestVoteTopCloseGUIOnClick() {
return getData().getBoolean("CHEST.VoteTop.CloseGUIOnClick", true);
}
public int getChestVoteTopSize() {
return getData().getInt("CHEST.VoteTop.Size", 27);
}
@@ -404,6 +427,11 @@ public class GUI extends YMLFile {
return getData().getConfigurationSection("CHEST.VoteTop.SwitchItem");
}
@SuppressWarnings("unchecked")
public ArrayList<String> getChestVoteTopSwitchItemTopVoters() {
return (ArrayList<String>) getData().getList("CHEST.VoteTop.SwitchItem.TopVoters", new ArrayList<String>());
}
public ConfigurationSection getChestVoteTotalAllTimeTotalItem() {
return getData().getConfigurationSection("CHEST.VoteTotal.AllTimeTotal.Item");
}
@@ -491,6 +519,28 @@ public class GUI extends YMLFile {
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 getChestGUIVoteShopExtraItems(String item) {
return getData().getConfigurationSection("CHEST.VoteShopExtraItems." + item);
}
public Set<String> getChestGUIVoteShopExtraItems() {
if (getData().isConfigurationSection("CHEST.VoteShopExtraItems")) {
return getData().getConfigurationSection("CHEST.VoteShopExtraItems").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.
*
@@ -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;
@@ -19,6 +20,9 @@ public class SpecialRewardsConfig extends YMLFile {
@Getter
private String allSitesRewardPath = "AllSites";
@Getter
private String almostAllSitesRewardPath = "AlmostAllSites";
@Getter
private String anySiteRewardsPath = "AnySiteRewards";
@@ -34,9 +38,13 @@ 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";
@@ -87,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.
*
@@ -220,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() {
@@ -258,6 +275,10 @@ public class SpecialRewardsConfig extends YMLFile {
return getData().getBoolean("VoteParty.OnlyOncePerDay");
}
public boolean getVotePartyOnlyOncePerWeek() {
return getData().getBoolean("VoteParty.OnlyOncePerWeek");
}
public boolean getVotePartyResetEachDay() {
return getData().getBoolean("VoteParty.ResetEachDay");
}
@@ -349,8 +370,8 @@ public class SpecialRewardsConfig extends YMLFile {
}
public void setMilestone(int intValue) {
getData().set("Milestones." + intValue + ".Enabled", true);
getData().set("Milestones." + intValue + ".Rewards.Messages.Player", "&aYou got %milestone% milestone votes!");
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 checkAll() {
if (!plugin.getConfigFile().isDisableCoolDownCheck() && RewardHandler.getInstance()
private ScheduledExecutorService timer;
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);
}
}
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() {
checkAll();
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 onCoolDownEnd(PlayerVoteCoolDownEndEvent event) {
RewardHandler.getInstance().giveReward(event.getPlayer(), plugin.getSpecialRewardsConfig().getData(),
"VoteCoolDownEndedReward",
new RewardOptions().addPlaceholder("Votesite", event.getVoteSite().getDisplayName()));
plugin.getRewardHandler().giveReward(event.getPlayer(), plugin.getSpecialRewardsConfig().getData(),
"VoteCoolDownEndedReward", new RewardOptions());
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onDayChangeEnd(DateChangedEvent event) {
checkAll();
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,37 @@ 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 updatePlaceholders() {
boolean data = getData().getBoolean("AutoCacheUpdated", false);
if (!data) {
List<String> placeholders = getAutoCachedPlaceholder();
for (int i = 0; i < placeholders.size(); i++) {
placeholders.set(i, placeholders.get(i).toLowerCase());
}
setAutoCachedPlaceholder(placeholders);
getData().set("AutoCacheUpdated", true);
saveData();
}
}
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)) {
@@ -139,7 +174,16 @@ public class ServerData {
public boolean isLastVotePartySameDay() {
int num = getData().getInt("LastVoteParty", 0);
if (num != plugin.getTimeChecker().getTime().getDayOfYear()) {
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;
@@ -246,10 +290,58 @@ public class ServerData {
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.
*/
public void updateValues() {
setVersion();
}
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 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;
}
/*
@@ -76,6 +76,14 @@ public class PlayerVoteEvent extends Event {
@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, FIRSTVOTETODAY;
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,13 +1,11 @@
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;
@@ -21,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.
@@ -29,7 +27,7 @@ public class PlayerJoinEvent implements Listener {
* @param plugin the plugin
*/
public PlayerJoinEvent(VotingPluginMain plugin) {
PlayerJoinEvent.plugin = plugin;
this.plugin = plugin;
}
private void login(Player player) {
@@ -49,9 +47,12 @@ 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.getPluginMessaging().sendPluginMessage("Login", user.getPlayerName(), user.getUUID(),
plugin.getBungeeSettings().getServer());
}
}
@@ -62,42 +63,29 @@ public class PlayerJoinEvent implements Listener {
*/
@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)) {
if (event.getPlayer() == null || !plugin.isMySQLOkay()) {
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);
}
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,17 @@ 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.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,90 +137,99 @@ 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());
plugin.getSpecialRewards().checkFirstVoteToday(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);
if (plugin.getConfigFile().isAutoCreateVoteSites() && createSite) {
plugin.getLogger().warning("VoteSite with service site '" + voteSiteNameStr
+ "' does not exist, attempting to generate...");
plugin.getConfigVoteSites().generateVoteSite(voteSiteNameStr);
plugin.getLogger().info("Current known service sites: "
+ ArrayUtils.getInstance().makeStringList(plugin.getServerData().getServiceSites()));
}
plugin.getLogger().info("Current known service sites: "
+ ArrayUtils.getInstance().makeStringList(plugin.getServerData().getServiceSites()));
}
PlayerVoteEvent voteEvent = new PlayerVoteEvent(plugin.getVoteSite(voteSiteName), voteUsername,
voteSite, true);
plugin.getServer().getPluginManager().callEvent(voteEvent);
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);
if (voteEvent.isCancelled()) {
plugin.debug("Vote cancelled");
return;
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;
@@ -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()));
}
File diff suppressed because it is too large. Load diff
Loaded 100 of 115 files, more files were not shown because too many files have changed in this diff. Show more