+                main.pay(event.getPlayer(), main.getPayouts().get(k), main.getPluginData().getPlayerData(event.getPlayer()).getPayoutData(k));

+import de.Linus122.TimeIsMoney.data.*;

+import de.Linus122.TimeIsMoney.tools.Utils;

+		String intervalString = getConfig().getString("global_interval", getConfig().getInt("give_money_every_second") + "s");

+		int globalTimerSeconds = Utils.parseTimeFormat(intervalString);

+

+				for(Payout payout : this.getApplicablePayoutsForPlayer(player)) {

+					PayoutData playerPayoutData = playerData.getPayoutData(payout.id);

+					playerPayoutData.setSecondsSinceLastPayout(playerPayoutData.getSecondsSinceLastPayout() + 1);

+

+					int intervalSeconds = payout.interval != 0 ? payout.interval : globalTimerSeconds;

+

+					if (playerPayoutData.getSecondsSinceLastPayout() >= intervalSeconds) {

+						// new payout triggered, handling the payout

+						pay(player, payout, playerPayoutData);

+						if(this.pluginData instanceof MySQLPluginData) {

+							// let other servers know of this payout

+							((MySQLPluginData) this.pluginData).createPendingPayout(player);

+						}

+						playerPayoutData.setSecondsSinceLastPayout(0);

+

+

+				payout.id = Integer.parseInt(key);

+				if (finalconfig.isSet("payouts." + key + ".interval")) {

+					// TODO: Add error message when parsing failed

+					payout.interval = Utils.parseTimeFormat(finalconfig.getString("payouts." + key + ".interval"));

+				}

+			List<Payout> payouts_ = payouts.stream().filter(payout -> player.hasPermission(payout.permission) || payout.permission.length() == 0).collect(Collectors.toList());

+

+			if(finalconfig.getBoolean("choose-only-one-payout", true)) {

+				List<Payout> finalPayouts = new ArrayList<>();

+				// add payouts with a custom timer anyways

+				finalPayouts.addAll(payouts_.stream().filter(payout -> payout.interval != 0).collect(Collectors.toList()));

+

+				// choose the last element of the payouts that does not have a custom timer

+				List<Payout> payoutsWithoutInterval = payouts_.stream().filter(payout -> payout.interval == 0).collect(Collectors.toList());

+				finalPayouts.add(payoutsWithoutInterval.get(payoutsWithoutInterval.size() - 1));

+				return finalPayouts;

+			} else if(this.getConfig().getBoolean("merge-payouts")) {

+				// Mering multiple payouts to one

+				Payout payout = new Payout();

+				payout.id = 1;

+				for (Payout payout_ : payouts_) {

+					if(payout_.interval != 0) {

+						continue;

+					}

+					payout.commands.addAll(payout_.commands);

+					payout.commands_if_afk.addAll(payout_.commands_if_afk);

+					payout.payout_amount += payout_.payout_amount;

+					payout.max_payout_per_day += payout_.max_payout_per_day;

+				}

+			}

+			return payouts_;

+	public void pay(Player player, Payout payout, PayoutData payoutPlayerData) {

+			if (payoutPlayerData.getReceivedToday() >= payout.max_payout_per_day) { //Reached max payout

+		payoutPlayerData.setReceivedToday(payoutPlayerData.getReceivedToday() + payout_amt);

+

+	public List<Payout> getPayouts() {

+		return payouts;

+	}

+	int id;

+

+	/**

+	 * Interval seconds

+	 */

+	int interval = 0;

+            String sqlCreate = "CREATE TABLE IF NOT EXISTS payoutData ("

+                    + "   uuid                     VARCHAR(36),"

+                    + "   id                       INT,"

+                    + "   lastPayoutDate           DATE,"

+                    + "   primary key (uuid, id))";

+        playerData.getPayoutDataMap().forEach((payoutID, payoutData) -> {

+            try {

+                PreparedStatement preparedStatement = connection

+                        .prepareStatement("REPLACE INTO playerData (uuid, payout_id receivedToday, secondsSinceLastPayout, lastPayoutDate) VALUES (?, ?, ?, ? ,?)");

+                preparedStatement.setString(1, uuid.toString());

+                preparedStatement.setInt(1, payoutID);

+                preparedStatement.setDouble(2, payoutData.getReceivedToday());

+                preparedStatement.setInt(3, payoutData.getSecondsSinceLastPayout());

+                preparedStatement.setDate(4, new java.sql.Date(payoutData.getLastPayoutDate().getTime()));

+

+                preparedStatement.execute();

+

+            } catch (SQLException e) {

+                e.printStackTrace();

+            }

+        });

+    private PayoutData readPayoutData(ResultSet result) throws SQLException {

+        return new PayoutData(receivedToday, date, secondsOnline);

+            PlayerData playerData = new PlayerData();

+            while(result.next()) {

+                UUID uuid = UUID.fromString(result.getString("uuid"));

+                int payoutID = result.getInt("payout_id");

+

+                PayoutData payoutData = this.readPayoutData(result);

+                playerData.getPayoutDataMap().put(payoutID, payoutData);

+                playerDataMap.put(uuid, playerData);

+package de.Linus122.TimeIsMoney.data;

+

+import org.apache.commons.lang.time.DateUtils;

+

+import java.util.Date;

+

+public class PayoutData {

+    private double receivedToday = 0d;

+    private Date lastPayoutDate;

+    private int secondsSinceLastPayout = 0;

+

+    public PayoutData(double receivedToday, Date lastPayoutDate, int secondsSinceLastPayout) {

+        this.receivedToday = receivedToday;

+        this.lastPayoutDate = lastPayoutDate;

+        this.secondsSinceLastPayout = secondsSinceLastPayout;

+    }

+

+    public double getReceivedToday() {

+        if(lastPayoutDate == null || !DateUtils.isSameDay(lastPayoutDate, new Date())) {

+            // new day, reset total money received

+            receivedToday = 0d;

+        }

+        return receivedToday;

+    }

+

+

+    /**

+     * Sets the total amount of money received for today and updates the {@link #lastPayoutDate} variable to now.

+     * @param receivedToday     Amount of money received today

+     * @since 1.9.7

+     */

+    public void setReceivedToday(double receivedToday) {

+        this.receivedToday = receivedToday;

+        lastPayoutDate = new Date();

+    }

+

+    public int getSecondsSinceLastPayout() {

+        return secondsSinceLastPayout;

+    }

+

+    public void setSecondsSinceLastPayout(int secondsSinceLastPayout) {

+        this.secondsSinceLastPayout = secondsSinceLastPayout;

+    }

+

+    public Date getLastPayoutDate() {

+        return lastPayoutDate;

+    }

+

+    public void setLastPayoutDate(Date lastPayoutDate) {

+        this.lastPayoutDate = lastPayoutDate;

+    }

+}

+import java.util.HashMap;

+import java.util.LinkedHashMap;

+public class PlayerData {

+    // stores per payout data (key as defined in config.yml)

+    private final HashMap<Integer, PayoutData> payoutData = new LinkedHashMap<>();

+    

+    public PayoutData getPayoutData(int payout_id) {

+        if(payoutData.containsKey(payout_id)) {

+            return payoutData.get(payout_id);

+        PayoutData payoutDataEntry = new PayoutData(0, new Date(), 0);

+        

+        payoutData.put(payout_id, payoutDataEntry);

+        

+        return payoutDataEntry;

+    public HashMap<Integer, PayoutData> getPayoutDataMap() {

+        return this.payoutData;

+                PlayerData playerData = new PlayerData();

+                for(String payout_id : yamlConfiguration.getConfigurationSection(key).getKeys(false)) {

+                    try {

+                        Integer.parseInt(payout_id);

+                    } catch(NumberFormatException e) {

+                        continue;

+                    }

+                    double receivedToday = yamlConfiguration.getDouble(key + "." + payout_id + ".receivedToday");

+                    int secondsOnline = yamlConfiguration.getInt(key + "." + payout_id + ".secondsSinceLastPayout");

+                    Date date = yamlConfiguration.getObject(key + "." + payout_id + ".lastPayoutDate", Date.class);

+

+                    PayoutData payoutData = new PayoutData(receivedToday, date, secondsOnline);

+                    playerData.getPayoutDataMap().put(Integer.parseInt(payout_id), payoutData);

+                }

+            playerData.getPayoutDataMap().forEach((payout_id, payoutData) -> {

+                yamlConfiguration.set(uuid + "." + payout_id + ".receivedToday" , payoutData.getReceivedToday());

+                yamlConfiguration.set(uuid + "." + payout_id + ".secondsSinceLastPayout" , payoutData.getSecondsSinceLastPayout());

+                yamlConfiguration.set(uuid + "." + payout_id + ".lastPayoutDate" , payoutData.getLastPayoutDate());

+            });

+            PlayerData playerData = new PlayerData();

+# doesn't merge payouts with individual intervals. Also doesn't merge when choose-only-one-payout is enabled.

+# Should it choose the last payout a player has permission for from the list? In the payout configuration below,

+# this would mean that VIPs (players with the tim.vip perm) would receive the last payout, while normal players the

+# first in the list. Does not apply for payouts with individual intervals

+choose-only-one-payout: true

+

+# Interval for all payouts; how long should a player need to play on the server to receive one of the payouts?

+# (previously called give_money_every_second)

+# It accepts seconds (s), minutes (m), and hours (h)

+global_interval: "10m"

+

+    permission: ""

+#  3:

+#    payout_amount: 1000

+#    max_payout_per_day: 10000

+#    # you can define a custom interval for individual payouts

+#    interval: 10h

+#    permission: ""

+

+

+	/**

+	 * Return the seconds of a time format, valid suffixes are s (seconds), m (minutes) and h (hours)

+	 * @param format the formatted time, examples: 10m, 8h, 30s.

+	 * @return converted seconds, invalid return -1

+	 */

+	public static int parseTimeFormat(String format) {

+		Pattern pattern = Pattern.compile("^(?:(\\d+)s|(\\d+)m|(\\d+)h)$");

+		Matcher matcher = pattern.matcher(format);

+

+		if (matcher.matches()) {

+			String seconds = matcher.group(1);

+			String minutes = matcher.group(2);

+			String hours = matcher.group(3);

+

+			if (seconds != null) {

+				return Integer.parseInt(seconds);

+			}

+			if (minutes != null) {

+				return Integer.parseInt(minutes) * 60;

+			}

+			if (hours != null) {

+				return Integer.parseInt(hours) * 60 * 60;

+			}

+		}

+		return -1;

+	}