    /**
     * returns sessions based on sort order defined
     *
     * @param sortedSet object that defines sort order
     * @return session list
     */
    public static SortedSet getSessions(SortedSet sortedSet) {
        //get db connection
        Connection con = null;
        List<SessionAudit> outputList = new LinkedList<>();

        String orderBy = "";
        if (sortedSet.getOrderByField() != null && !sortedSet.getOrderByField().trim().equals("")) {
            orderBy = " order by " + sortedSet.getOrderByField() + " " + sortedSet.getOrderByDirection();
        }

        String sql = "select * from session_log, users where users.id= session_log.user_id ";
        sql+= StringUtils.isNotEmpty(sortedSet.getFilterMap().get(FILTER_BY_USER_ID)) ? " and session_log.user_id=? " : "";
        sql+= StringUtils.isNotEmpty(sortedSet.getFilterMap().get(FILTER_BY_SYSTEM_ID)) ? " and session_log.id in ( select session_id from terminal_log where terminal_log.system_id=? ) " : "";
        sql+= orderBy;

        try {

            con = DBUtils.getConn();
            deleteAuditHistory(con);

            PreparedStatement stmt = con.prepareStatement(sql);
            int i=1;
            //set filters in prepared statement
            if(StringUtils.isNotEmpty(sortedSet.getFilterMap().get(FILTER_BY_USER_ID))){
                stmt.setLong(i++, Long.valueOf(sortedSet.getFilterMap().get(FILTER_BY_USER_ID)));
            }
            if(StringUtils.isNotEmpty(sortedSet.getFilterMap().get(FILTER_BY_SYSTEM_ID))){
                stmt.setLong(i++, Long.valueOf(sortedSet.getFilterMap().get(FILTER_BY_SYSTEM_ID)));
            }

            ResultSet rs = stmt.executeQuery();
            while (rs.next()) {
                SessionAudit sessionAudit = new SessionAudit();
                sessionAudit.setId(rs.getLong("session_log.id"));
                sessionAudit.setSessionTm(rs.getTimestamp("session_tm"));
                sessionAudit.setUser(UserDB.getUser(con, rs.getLong("user_id")));
                outputList.add(sessionAudit);

            }

            DBUtils.closeStmt(stmt);

        } catch (Exception e) {
            log.error(e.toString(), e);
        }
        //close db connection
        DBUtils.closeConn(con);

        sortedSet.setItemList(outputList);

        return sortedSet;

    }

    /**
     * returns sessions based on sort order defined
     *
     * @param sortedSet object that defines sort order
     * @return session list
     */
    public static SortedSet getSessions(SortedSet sortedSet) {
        //get db connection
        Connection con = null;
        List<SessionAudit> outputList = new LinkedList<SessionAudit>();

        String orderBy = "";
        if (sortedSet.getOrderByField() != null && !sortedSet.getOrderByField().trim().equals("")) {
            orderBy = " order by " + sortedSet.getOrderByField() + " " + sortedSet.getOrderByDirection();
        }

        String sql = "select * from session_log, users where users.id= session_log.user_id ";
        sql+= StringUtils.isNotEmpty(sortedSet.getFilterMap().get(FILTER_BY_USER_ID)) ? " and session_log.user_id=? " : "";
        sql+= StringUtils.isNotEmpty(sortedSet.getFilterMap().get(FILTER_BY_SYSTEM_ID)) ? " and session_log.id in ( select session_id from terminal_log where terminal_log.system_id=? ) " : "";
        sql+= orderBy;

        try {

            con = DBUtils.getConn();
            deleteAuditHistory(con);

            PreparedStatement stmt = con.prepareStatement(sql);
            int i=1;
            //set filters in prepared statement
            if(StringUtils.isNotEmpty(sortedSet.getFilterMap().get(FILTER_BY_USER_ID))){
                stmt.setLong(i++, Long.valueOf(sortedSet.getFilterMap().get(FILTER_BY_USER_ID)));
            }
            if(StringUtils.isNotEmpty(sortedSet.getFilterMap().get(FILTER_BY_SYSTEM_ID))){
                stmt.setLong(i++, Long.valueOf(sortedSet.getFilterMap().get(FILTER_BY_SYSTEM_ID)));
            }

            ResultSet rs = stmt.executeQuery();
            while (rs.next()) {
                SessionAudit sessionAudit = new SessionAudit();
                sessionAudit.setId(rs.getLong("session_log.id"));
                sessionAudit.setSessionTm(rs.getTimestamp("session_tm"));
                sessionAudit.setUser(UserDB.getUser(con, rs.getLong("user_id")));
                outputList.add(sessionAudit);

            }

            DBUtils.closeStmt(stmt);

        } catch (Exception e) {
            log.error(e.toString(), e);
        }
        //close db connection
        DBUtils.closeConn(con);

        sortedSet.setItemList(outputList);

        return sortedSet;

    }

Replace Generic With Diamond LinkedList<SessionAudit> with LinkedList<> in method public getSessions(sortedSet SortedSet) : SortedSet from class com.keybox.manage.db.SessionAuditDB


    /**
     * returns terminal logs for user session for host system
     *
     * @param sessionId     session id
     * @param instanceId    instance id for terminal session
     * @return session output for session
     */
    public static List<SessionOutput> getTerminalLogsForSession(Connection con, Long sessionId, Integer instanceId) {

        List<SessionOutput> outputList = new LinkedList<>();
        try {
            PreparedStatement stmt = con.prepareStatement("select * from terminal_log where instance_id=? and session_id=? order by log_tm asc");
            stmt.setLong(1, instanceId);
            stmt.setLong(2, sessionId);
            ResultSet rs = stmt.executeQuery();
            String output = "";
            while (rs.next()) {
                output = output + rs.getString("output");
            }

            output = output.replaceAll("\\u0007|\u001B\\[K|\\]0;|\\[\\d\\d;\\d\\dm|\\[\\dm","");
            while (output.contains("\b")) {
                output = output.replaceFirst(".\b", "");
            }
            DBUtils.closeRs(rs);

            SessionOutput sessionOutput = new SessionOutput();
            sessionOutput.setSessionId(sessionId);
            sessionOutput.setInstanceId(instanceId);
            sessionOutput.getOutput().append(output);

            outputList.add(sessionOutput);

            DBUtils.closeRs(rs);

            DBUtils.closeStmt(stmt);

        } catch (Exception e) {
            log.error(e.toString(), e);
        }
        return outputList;

    }

    /**
     * returns terminal logs for user session for host system
     *
     * @param sessionId     session id
     * @param instanceId    instance id for terminal session
     * @return session output for session
     */
    public static List<SessionOutput> getTerminalLogsForSession(Connection con, Long sessionId, Integer instanceId) {

        List<SessionOutput> outputList = new LinkedList<SessionOutput>();
        try {
            PreparedStatement stmt = con.prepareStatement("select * from terminal_log where instance_id=? and session_id=? order by log_tm asc");
            stmt.setLong(1, instanceId);
            stmt.setLong(2, sessionId);
            ResultSet rs = stmt.executeQuery();
            String output = "";
            while (rs.next()) {
                output = output + rs.getString("output");
            }

            output = output.replaceAll("\\u0007|\u001B\\[K|\\]0;|\\[\\d\\d;\\d\\dm|\\[\\dm","");
            while (output.contains("\b")) {
                output = output.replaceFirst(".\b", "");
            }
            DBUtils.closeRs(rs);

            SessionOutput sessionOutput = new SessionOutput();
            sessionOutput.setSessionId(sessionId);
            sessionOutput.setInstanceId(instanceId);
            sessionOutput.getOutput().append(output);

            outputList.add(sessionOutput);

            DBUtils.closeRs(rs);

            DBUtils.closeStmt(stmt);

        } catch (Exception e) {
            log.error(e.toString(), e);
        }
        return outputList;

    }

Replace Generic With Diamond LinkedList<SessionOutput> with LinkedList<> in method public getTerminalLogsForSession(con Connection, sessionId Long, instanceId Integer) : List<SessionOutput> from class com.keybox.manage.db.SessionAuditDB


    /**
     * returns terminal logs for user session for host system
     *
     * @param con       DB connection
     * @param sessionId session id
     * @return session output for session
     */
    public static List<HostSystem> getHostSystemsForSession(Connection con, Long sessionId) {

        List<HostSystem> hostSystemList = new ArrayList<>();
        try {
            PreparedStatement stmt = con.prepareStatement("select distinct instance_id, system_id from terminal_log where session_id=?");
            stmt.setLong(1, sessionId);
            ResultSet rs = stmt.executeQuery();
            while (rs.next()) {
                HostSystem hostSystem = SystemDB.getSystem(con, rs.getLong("system_id"));
                hostSystem.setInstanceId(rs.getInt("instance_id"));
                hostSystemList.add(hostSystem);
            }

            DBUtils.closeRs(rs);
            DBUtils.closeStmt(stmt);

        } catch (Exception ex) {
            log.error(ex.toString(), ex);
        }
        return hostSystemList;

    }

    /**
     * returns terminal logs for user session for host system
     *
     * @param con       DB connection
     * @param sessionId session id
     * @return session output for session
     */
    public static List<HostSystem> getHostSystemsForSession(Connection con, Long sessionId) {

        List<HostSystem> hostSystemList = new ArrayList<HostSystem>();
        try {
            PreparedStatement stmt = con.prepareStatement("select distinct instance_id, system_id from terminal_log where session_id=?");
            stmt.setLong(1, sessionId);
            ResultSet rs = stmt.executeQuery();
            while (rs.next()) {
                HostSystem hostSystem = SystemDB.getSystem(con, rs.getLong("system_id"));
                hostSystem.setInstanceId(rs.getInt("instance_id"));
                hostSystemList.add(hostSystem);
            }

            DBUtils.closeRs(rs);
            DBUtils.closeStmt(stmt);

        } catch (Exception ex) {
            log.error(ex.toString(), ex);
        }
        return hostSystemList;

    }

Replace Generic With Diamond ArrayList<HostSystem> with ArrayList<> in method public getHostSystemsForSession(con Connection, sessionId Long) : List<HostSystem> from class com.keybox.manage.db.SessionAuditDB


	/**
	 * method to do order by based on the sorted set object for systems for user
	 *
	 * @param sortedSet sorted set object
	 * @param userId    user id
	 * @return sortedSet with list of host systems
	 */
	public static SortedSet getUserSystemSet(SortedSet sortedSet, Long userId) {
		List<HostSystem> hostSystemList = new ArrayList<>();

		String orderBy = "";
		if (sortedSet.getOrderByField() != null && !sortedSet.getOrderByField().trim().equals("")) {
			orderBy = "order by " + sortedSet.getOrderByField() + " " + sortedSet.getOrderByDirection();
		}
		String sql = "select * from system where id in (select distinct system_id from  system_map m, user_map um where m.profile_id=um.profile_id and um.user_id=? ";
		//if profile id exists add to statement
		sql += StringUtils.isNotEmpty(sortedSet.getFilterMap().get(FILTER_BY_PROFILE_ID)) ? " and um.profile_id=? " : "";
		sql += ") " + orderBy;

		//get user for auth token
		Connection con = null;
		try {
			con = DBUtils.getConn();
			PreparedStatement stmt = con.prepareStatement(sql);
			stmt.setLong(1, userId);
			//filter by profile id if exists
			if (StringUtils.isNotEmpty(sortedSet.getFilterMap().get(FILTER_BY_PROFILE_ID))) {
				stmt.setLong(2, Long.valueOf(sortedSet.getFilterMap().get(FILTER_BY_PROFILE_ID)));
			}

			ResultSet rs = stmt.executeQuery();

			while (rs.next()) {
				HostSystem hostSystem = new HostSystem();
				hostSystem.setId(rs.getLong("id"));
				hostSystem.setDisplayNm(rs.getString("display_nm"));
				hostSystem.setUser(rs.getString("user"));
				hostSystem.setHost(rs.getString("host"));
				hostSystem.setPort(rs.getInt("port"));
				hostSystem.setAuthorizedKeys(rs.getString("authorized_keys"));
				hostSystem.setStatusCd(rs.getString("status_cd"));
				hostSystemList.add(hostSystem);
			}
			DBUtils.closeRs(rs);
			DBUtils.closeStmt(stmt);

		} catch (Exception e) {
			log.error(e.toString(), e);
		}
		DBUtils.closeConn(con);

		sortedSet.setItemList(hostSystemList);
		return sortedSet;

	}

	/**
	 * method to do order by based on the sorted set object for systems for user
	 *
	 * @param sortedSet sorted set object
	 * @param userId    user id
	 * @return sortedSet with list of host systems
	 */
	public static SortedSet getUserSystemSet(SortedSet sortedSet, Long userId) {
		List<HostSystem> hostSystemList = new ArrayList<HostSystem>();

		String orderBy = "";
		if (sortedSet.getOrderByField() != null && !sortedSet.getOrderByField().trim().equals("")) {
			orderBy = "order by " + sortedSet.getOrderByField() + " " + sortedSet.getOrderByDirection();
		}
		String sql = "select * from system where id in (select distinct system_id from  system_map m, user_map um where m.profile_id=um.profile_id and um.user_id=? ";
		//if profile id exists add to statement
		sql += StringUtils.isNotEmpty(sortedSet.getFilterMap().get(FILTER_BY_PROFILE_ID)) ? " and um.profile_id=? " : "";
		sql += ") " + orderBy;

		//get user for auth token
		Connection con = null;
		try {
			con = DBUtils.getConn();
			PreparedStatement stmt = con.prepareStatement(sql);
			stmt.setLong(1, userId);
			//filter by profile id if exists
			if (StringUtils.isNotEmpty(sortedSet.getFilterMap().get(FILTER_BY_PROFILE_ID))) {
				stmt.setLong(2, Long.valueOf(sortedSet.getFilterMap().get(FILTER_BY_PROFILE_ID)));
			}

			ResultSet rs = stmt.executeQuery();

			while (rs.next()) {
				HostSystem hostSystem = new HostSystem();
				hostSystem.setId(rs.getLong("id"));
				hostSystem.setDisplayNm(rs.getString("display_nm"));
				hostSystem.setUser(rs.getString("user"));
				hostSystem.setHost(rs.getString("host"));
				hostSystem.setPort(rs.getInt("port"));
				hostSystem.setAuthorizedKeys(rs.getString("authorized_keys"));
				hostSystem.setStatusCd(rs.getString("status_cd"));
				hostSystemList.add(hostSystem);
			}
			DBUtils.closeRs(rs);
			DBUtils.closeStmt(stmt);

		} catch (Exception e) {
			log.error(e.toString(), e);
		}
		DBUtils.closeConn(con);

		sortedSet.setItemList(hostSystemList);
		return sortedSet;

	}

Replace Generic With Diamond ArrayList<HostSystem> with ArrayList<> in method public getUserSystemSet(sortedSet SortedSet, userId Long) : SortedSet from class com.keybox.manage.db.SystemDB


	/**
	 * method to do order by based on the sorted set object for systems
	 *
	 * @param sortedSet sorted set object
	 * @return sortedSet with list of host systems
	 */
	public static SortedSet getSystemSet(SortedSet sortedSet) {
		List<HostSystem> hostSystemList = new ArrayList<>();

		String orderBy = "";
		if (sortedSet.getOrderByField() != null && !sortedSet.getOrderByField().trim().equals("")) {
			orderBy = "order by " + sortedSet.getOrderByField() + " " + sortedSet.getOrderByDirection();
		}
		String sql = "select * from  system s ";
		//if profile id exists add to statement
		sql += StringUtils.isNotEmpty(sortedSet.getFilterMap().get(FILTER_BY_PROFILE_ID)) ? ",system_map m where s.id=m.system_id and m.profile_id=?" : "";
		sql += orderBy;

		Connection con = null;
		try {
			con = DBUtils.getConn();
			PreparedStatement stmt = con.prepareStatement(sql);
			if (StringUtils.isNotEmpty(sortedSet.getFilterMap().get(FILTER_BY_PROFILE_ID))) {
				stmt.setLong(1, Long.valueOf(sortedSet.getFilterMap().get(FILTER_BY_PROFILE_ID)));
			}
			ResultSet rs = stmt.executeQuery();

			while (rs.next()) {
				HostSystem hostSystem = new HostSystem();
				hostSystem.setId(rs.getLong("id"));
				hostSystem.setDisplayNm(rs.getString("display_nm"));
				hostSystem.setUser(rs.getString("user"));
				hostSystem.setHost(rs.getString("host"));
				hostSystem.setPort(rs.getInt("port"));
				hostSystem.setAuthorizedKeys(rs.getString("authorized_keys"));
				hostSystem.setStatusCd(rs.getString("status_cd"));
				hostSystemList.add(hostSystem);
			}
			DBUtils.closeRs(rs);
			DBUtils.closeStmt(stmt);

		} catch (Exception e) {
			log.error(e.toString(), e);
		}
		DBUtils.closeConn(con);

		sortedSet.setItemList(hostSystemList);
		return sortedSet;

	}

	/**
	 * method to do order by based on the sorted set object for systems
	 *
	 * @param sortedSet sorted set object
	 * @return sortedSet with list of host systems
	 */
	public static SortedSet getSystemSet(SortedSet sortedSet) {
		List<HostSystem> hostSystemList = new ArrayList<HostSystem>();

		String orderBy = "";
		if (sortedSet.getOrderByField() != null && !sortedSet.getOrderByField().trim().equals("")) {
			orderBy = "order by " + sortedSet.getOrderByField() + " " + sortedSet.getOrderByDirection();
		}
		String sql = "select * from  system s ";
		//if profile id exists add to statement
		sql += StringUtils.isNotEmpty(sortedSet.getFilterMap().get(FILTER_BY_PROFILE_ID)) ? ",system_map m where s.id=m.system_id and m.profile_id=?" : "";
		sql += orderBy;

		Connection con = null;
		try {
			con = DBUtils.getConn();
			PreparedStatement stmt = con.prepareStatement(sql);
			if (StringUtils.isNotEmpty(sortedSet.getFilterMap().get(FILTER_BY_PROFILE_ID))) {
				stmt.setLong(1, Long.valueOf(sortedSet.getFilterMap().get(FILTER_BY_PROFILE_ID)));
			}
			ResultSet rs = stmt.executeQuery();

			while (rs.next()) {
				HostSystem hostSystem = new HostSystem();
				hostSystem.setId(rs.getLong("id"));
				hostSystem.setDisplayNm(rs.getString("display_nm"));
				hostSystem.setUser(rs.getString("user"));
				hostSystem.setHost(rs.getString("host"));
				hostSystem.setPort(rs.getInt("port"));
				hostSystem.setAuthorizedKeys(rs.getString("authorized_keys"));
				hostSystem.setStatusCd(rs.getString("status_cd"));
				hostSystemList.add(hostSystem);
			}
			DBUtils.closeRs(rs);
			DBUtils.closeStmt(stmt);

		} catch (Exception e) {
			log.error(e.toString(), e);
		}
		DBUtils.closeConn(con);

		sortedSet.setItemList(hostSystemList);
		return sortedSet;

	}

Replace Generic With Diamond ArrayList<HostSystem> with ArrayList<> in method public getSystemSet(sortedSet SortedSet) : SortedSet from class com.keybox.manage.db.SystemDB


	/**
	 * returns the host systems
	 *
	 * @param systemIdList list of host system ids
	 * @return host system with array of public keys
	 */
	public static List<HostSystem> getSystems(List<Long> systemIdList) {

		Connection con = null;
		List<HostSystem> hostSystemListReturn = new ArrayList<>();

		try {
			con = DBUtils.getConn();
			for (Long systemId : systemIdList) {
				HostSystem hostSystem = getSystem(con, systemId);
				hostSystemListReturn.add(hostSystem);
			}

		} catch (Exception e) {
			log.error(e.toString(), e);
		}
		DBUtils.closeConn(con);

		return hostSystemListReturn;

	}

	/**
	 * returns the host systems
	 *
	 * @param systemIdList list of host system ids
	 * @return host system with array of public keys
	 */
	public static List<HostSystem> getSystems(List<Long> systemIdList) {

		Connection con = null;
		List<HostSystem> hostSystemListReturn = new ArrayList<HostSystem>();

		try {
			con = DBUtils.getConn();
			for (Long systemId : systemIdList) {
				HostSystem hostSystem = getSystem(con, systemId);
				hostSystemListReturn.add(hostSystem);
			}

		} catch (Exception e) {
			log.error(e.toString(), e);
		}
		DBUtils.closeConn(con);

		return hostSystemListReturn;

	}

Replace Generic With Diamond ArrayList<HostSystem> with ArrayList<> in method public getSystems(systemIdList List<Long>) : List<HostSystem> from class com.keybox.manage.db.SystemDB


	/**
	 * returns all systems
	 *
	 * @return system list
	 */
	public static List<HostSystem> getAllSystems() {

		List<HostSystem> hostSystemList = new ArrayList<>();

		Connection con = null;

		try {
			con=DBUtils.getConn();
			PreparedStatement stmt = con.prepareStatement("select * from  system");
			ResultSet rs = stmt.executeQuery();

			while (rs.next()) {
				HostSystem hostSystem = new HostSystem();
				hostSystem.setId(rs.getLong("id"));
				hostSystem.setDisplayNm(rs.getString("display_nm"));
				hostSystem.setUser(rs.getString("user"));
				hostSystem.setHost(rs.getString("host"));
				hostSystem.setPort(rs.getInt("port"));
				hostSystem.setAuthorizedKeys(rs.getString("authorized_keys"));
				hostSystem.setStatusCd(rs.getString("status_cd"));
				hostSystemList.add(hostSystem);
			}
			DBUtils.closeRs(rs);
			DBUtils.closeStmt(stmt);

		} catch (Exception e) {
			log.error(e.toString(), e);
		}

		DBUtils.closeConn(con);

		return hostSystemList;

	}

	/**
	 * returns all systems
	 *
	 * @return system list
	 */
	public static List<HostSystem> getAllSystems() {

		List<HostSystem> hostSystemList = new ArrayList<HostSystem>();

		Connection con = null;

		try {
			con=DBUtils.getConn();
			PreparedStatement stmt = con.prepareStatement("select * from  system");
			ResultSet rs = stmt.executeQuery();

			while (rs.next()) {
				HostSystem hostSystem = new HostSystem();
				hostSystem.setId(rs.getLong("id"));
				hostSystem.setDisplayNm(rs.getString("display_nm"));
				hostSystem.setUser(rs.getString("user"));
				hostSystem.setHost(rs.getString("host"));
				hostSystem.setPort(rs.getInt("port"));
				hostSystem.setAuthorizedKeys(rs.getString("authorized_keys"));
				hostSystem.setStatusCd(rs.getString("status_cd"));
				hostSystemList.add(hostSystem);
			}
			DBUtils.closeRs(rs);
			DBUtils.closeStmt(stmt);

		} catch (Exception e) {
			log.error(e.toString(), e);
		}

		DBUtils.closeConn(con);

		return hostSystemList;

	}

Replace Generic With Diamond ArrayList<HostSystem> with ArrayList<> in method public getAllSystems() : List<HostSystem> from class com.keybox.manage.db.SystemDB


	/**
	 * returns all system ids
	 *
	 * @param con DB connection
	 * @return system
	 */
	public static List<Long> getAllSystemIds(Connection con) {

		List<Long> systemIdList = new ArrayList<>();

		try {
			PreparedStatement stmt = con.prepareStatement("select * from  system");
			ResultSet rs = stmt.executeQuery();

			while (rs.next()) {
				systemIdList.add(rs.getLong("id"));
			}
			DBUtils.closeRs(rs);
			DBUtils.closeStmt(stmt);

		} catch (Exception e) {
			log.error(e.toString(), e);
		}

		return systemIdList;

	}

	/**
	 * returns all system ids
	 *
	 * @param con DB connection
	 * @return system
	 */
	public static List<Long> getAllSystemIds(Connection con) {

		List<Long> systemIdList = new ArrayList<Long>();

		try {
			PreparedStatement stmt = con.prepareStatement("select * from  system");
			ResultSet rs = stmt.executeQuery();

			while (rs.next()) {
				systemIdList.add(rs.getLong("id"));
			}
			DBUtils.closeRs(rs);
			DBUtils.closeStmt(stmt);

		} catch (Exception e) {
			log.error(e.toString(), e);
		}

		return systemIdList;

	}

Replace Generic With Diamond ArrayList<Long> with ArrayList<> in method public getAllSystemIds(con Connection) : List<Long> from class com.keybox.manage.db.SystemDB


	/**
	 * returns all system ids for user
	 *
	 * @param con    DB connection
	 * @param userId user id
	 * @return system
	 */
	public static List<Long> getAllSystemIdsForUser(Connection con, Long userId) {

		List<Long> systemIdList = new ArrayList<>();

		try {
			PreparedStatement stmt = con.prepareStatement("select distinct system_id from  system_map m, user_map um where m.profile_id=um.profile_id and um.user_id=?");
			stmt.setLong(1, userId);
			ResultSet rs = stmt.executeQuery();

			while (rs.next()) {
				systemIdList.add(rs.getLong("system_id"));
			}
			DBUtils.closeRs(rs);
			DBUtils.closeStmt(stmt);

		} catch (Exception e) {
			log.error(e.toString(), e);
		}

		return systemIdList;

	}

	/**
	 * returns all system ids for user
	 *
	 * @param con    DB connection
	 * @param userId user id
	 * @return system
	 */
	public static List<Long> getAllSystemIdsForUser(Connection con, Long userId) {

		List<Long> systemIdList = new ArrayList<Long>();

		try {
			PreparedStatement stmt = con.prepareStatement("select distinct system_id from  system_map m, user_map um where m.profile_id=um.profile_id and um.user_id=?");
			stmt.setLong(1, userId);
			ResultSet rs = stmt.executeQuery();

			while (rs.next()) {
				systemIdList.add(rs.getLong("system_id"));
			}
			DBUtils.closeRs(rs);
			DBUtils.closeStmt(stmt);

		} catch (Exception e) {
			log.error(e.toString(), e);
		}

		return systemIdList;

	}

Replace Generic With Diamond ArrayList<Long> with ArrayList<> in method public getAllSystemIdsForUser(con Connection, userId Long) : List<Long> from class com.keybox.manage.db.SystemDB


	/**
	 * returns all system ids for user
	 *
	 * @param userId user id
	 * @return system
	 */
	public static List<Long> getAllSystemIdsForUser(Long userId) {
		Connection con = null;
		List<Long> systemIdList = new ArrayList<>();
		try {
			con = DBUtils.getConn();
			systemIdList = getAllSystemIdsForUser(con, userId);

		} catch (Exception ex) {
			log.error(ex.toString(), ex);
		}
		DBUtils.closeConn(con);
		return systemIdList;
	}

	/**
	 * returns all system ids for user
	 *
	 * @param userId user id
	 * @return system
	 */
	public static List<Long> getAllSystemIdsForUser(Long userId) {
		Connection con = null;
		List<Long> systemIdList = new ArrayList<Long>();
		try {
			con = DBUtils.getConn();
			systemIdList = getAllSystemIdsForUser(con, userId);

		} catch (Exception ex) {
			log.error(ex.toString(), ex);
		}
		DBUtils.closeConn(con);
		return systemIdList;
	}

Replace Generic With Diamond ArrayList<Long> with ArrayList<> in method public getAllSystemIdsForUser(userId Long) : List<Long> from class com.keybox.manage.db.SystemDB


	/**
	 * returns all system ids
	 *
	 * @return system
	 */
	public static List<Long> getAllSystemIds() {
		Connection con = null;
		List<Long> systemIdList = new ArrayList<>();
		try {
			con = DBUtils.getConn();
			systemIdList = getAllSystemIds(con);

		} catch (Exception ex) {
			log.error(ex.toString(), ex);
		}
		DBUtils.closeConn(con);
		return systemIdList;

	}

	/**
	 * returns all system ids
	 *
	 * @return system
	 */
	public static List<Long> getAllSystemIds() {
		Connection con = null;
		List<Long> systemIdList = new ArrayList<Long>();
		try {
			con = DBUtils.getConn();
			systemIdList = getAllSystemIds(con);

		} catch (Exception ex) {
			log.error(ex.toString(), ex);
		}
		DBUtils.closeConn(con);
		return systemIdList;

	}

Replace Generic With Diamond ArrayList<Long> with ArrayList<> in method public getAllSystemIds() : List<Long> from class com.keybox.manage.db.SystemDB


	/**
	 * method to check system permissions for user
	 *
	 * @param con DB connection
	 * @param systemSelectIdList list of system ids to check
	 * @param userId             user id
	 * @return only system ids that user has perms for
	 */
	public static List<Long> checkSystemPerms(Connection con, List<Long> systemSelectIdList, Long userId) {

		List<Long> systemIdList = new ArrayList<>();
		List<Long> userSystemIdList = getAllSystemIdsForUser(con, userId);

		for (Long systemId : userSystemIdList) {
			if (systemSelectIdList.contains(systemId)) {
				systemIdList.add(systemId);
			}
		}

		return systemIdList;

	}

	/**
	 * method to check system permissions for user
	 *
	 * @param con DB connection
	 * @param systemSelectIdList list of system ids to check
	 * @param userId             user id
	 * @return only system ids that user has perms for
	 */
	public static List<Long> checkSystemPerms(Connection con, List<Long> systemSelectIdList, Long userId) {

		List<Long> systemIdList = new ArrayList<Long>();
		List<Long> userSystemIdList = getAllSystemIdsForUser(con, userId);

		for (Long systemId : userSystemIdList) {
			if (systemSelectIdList.contains(systemId)) {
				systemIdList.add(systemId);
			}
		}

		return systemIdList;

	}

Replace Generic With Diamond ArrayList<Long> with ArrayList<> in method public checkSystemPerms(con Connection, systemSelectIdList List<Long>, userId Long) : List<Long> from class com.keybox.manage.db.SystemDB


    /**
     * returns all key placement statuses
     * @param userId user id
     */
    public static List<HostSystem> getAllSystemStatus(Long userId) {

        List<HostSystem> hostSystemList = new ArrayList<>();
        Connection con = null;
        try {
            con = DBUtils.getConn();
            hostSystemList = getAllSystemStatus(con, userId);

        } catch (Exception e) {
            log.error(e.toString(), e);
        }
        DBUtils.closeConn(con);
        return hostSystemList;

    }

    /**
     * returns all key placement statuses
     * @param userId user id
     */
    public static List<HostSystem> getAllSystemStatus(Long userId) {

        List<HostSystem> hostSystemList = new ArrayList<HostSystem>();
        Connection con = null;
        try {
            con = DBUtils.getConn();
            hostSystemList = getAllSystemStatus(con, userId);

        } catch (Exception e) {
            log.error(e.toString(), e);
        }
        DBUtils.closeConn(con);
        return hostSystemList;

    }

Replace Generic With Diamond ArrayList<HostSystem> with ArrayList<> in method public getAllSystemStatus(userId Long) : List<HostSystem> from class com.keybox.manage.db.SystemStatusDB


    /**
     * returns all key placement statuses
     *
     * @param con DB connection object
     * @param userId user id
     */
    private static List<HostSystem> getAllSystemStatus(Connection con, Long userId) {

        List<HostSystem> hostSystemList = new ArrayList<>();
        try {

            PreparedStatement stmt = con.prepareStatement("select * from status where user_id=? order by id asc");
            stmt.setLong(1, userId);
            ResultSet rs = stmt.executeQuery();

            while (rs.next()) {
                HostSystem hostSystem = SystemDB.getSystem(con, rs.getLong("id"));
                hostSystem.setStatusCd(rs.getString("status_cd"));
                hostSystemList.add(hostSystem);
            }
            DBUtils.closeRs(rs);
            DBUtils.closeStmt(stmt);

        } catch (Exception e) {
            log.error(e.toString(), e);
        }
        return hostSystemList;

    }

    /**
     * returns all key placement statuses
     *
     * @param con DB connection object
     * @param userId user id
     */
    private static List<HostSystem> getAllSystemStatus(Connection con, Long userId) {

        List<HostSystem> hostSystemList = new ArrayList<HostSystem>();
        try {

            PreparedStatement stmt = con.prepareStatement("select * from status where user_id=? order by id asc");
            stmt.setLong(1, userId);
            ResultSet rs = stmt.executeQuery();

            while (rs.next()) {
                HostSystem hostSystem = SystemDB.getSystem(con, rs.getLong("id"));
                hostSystem.setStatusCd(rs.getString("status_cd"));
                hostSystemList.add(hostSystem);
            }
            DBUtils.closeRs(rs);
            DBUtils.closeStmt(stmt);

        } catch (Exception e) {
            log.error(e.toString(), e);
        }
        return hostSystemList;

    }

Replace Generic With Diamond ArrayList<HostSystem> with ArrayList<> in method private getAllSystemStatus(con Connection, userId Long) : List<HostSystem> from class com.keybox.manage.db.SystemStatusDB


    /**
     * returns users based on sort order defined
     * @param sortedSet object that defines sort order
     * @return sorted user list
     */
    public static SortedSet getUserSet(SortedSet sortedSet) {

        ArrayList<User> userList = new ArrayList<>();

        String orderBy = "";
        if (sortedSet.getOrderByField() != null && !sortedSet.getOrderByField().trim().equals("")) {
            orderBy = "order by " + sortedSet.getOrderByField() + " " + sortedSet.getOrderByDirection();
        }
        String sql = "select * from  users where enabled=true " + orderBy;

        Connection con = null;
        try {
            con = DBUtils.getConn();
            PreparedStatement stmt = con.prepareStatement(sql);
            ResultSet rs = stmt.executeQuery();
            while (rs.next()) {
                User user = new User();
                user.setId(rs.getLong("id"));
                user.setFirstNm(rs.getString("first_nm"));
                user.setLastNm(rs.getString("last_nm"));
                user.setEmail(rs.getString("email"));
                user.setUsername(rs.getString("username"));
                user.setPassword(rs.getString("password"));
                user.setAuthType(rs.getString("auth_type"));
                user.setUserType(rs.getString("user_type"));
                userList.add(user);

            }
            DBUtils.closeRs(rs);
            DBUtils.closeStmt(stmt);

        } catch (Exception e) {
            log.error(e.toString(), e);
        }
        DBUtils.closeConn(con);

        sortedSet.setItemList(userList);
        return sortedSet;
    }

    /**
     * returns users based on sort order defined
     * @param sortedSet object that defines sort order
     * @return sorted user list
     */
    public static SortedSet getUserSet(SortedSet sortedSet) {

        ArrayList<User> userList = new ArrayList<User>();

        String orderBy = "";
        if (sortedSet.getOrderByField() != null && !sortedSet.getOrderByField().trim().equals("")) {
            orderBy = "order by " + sortedSet.getOrderByField() + " " + sortedSet.getOrderByDirection();
        }
        String sql = "select * from  users where enabled=true " + orderBy;

        Connection con = null;
        try {
            con = DBUtils.getConn();
            PreparedStatement stmt = con.prepareStatement(sql);
            ResultSet rs = stmt.executeQuery();
            while (rs.next()) {
                User user = new User();
                user.setId(rs.getLong("id"));
                user.setFirstNm(rs.getString("first_nm"));
                user.setLastNm(rs.getString("last_nm"));
                user.setEmail(rs.getString("email"));
                user.setUsername(rs.getString("username"));
                user.setPassword(rs.getString("password"));
                user.setAuthType(rs.getString("auth_type"));
                user.setUserType(rs.getString("user_type"));
                userList.add(user);

            }
            DBUtils.closeRs(rs);
            DBUtils.closeStmt(stmt);

        } catch (Exception e) {
            log.error(e.toString(), e);
        }
        DBUtils.closeConn(con);

        sortedSet.setItemList(userList);
        return sortedSet;
    }

Replace Generic With Diamond ArrayList<User> with ArrayList<> in method public getUserSet(sortedSet SortedSet) : SortedSet from class com.keybox.manage.db.UserDB


    /**
     * returns all admin users based on sort order defined
     * @param sortedSet object that defines sort order
     * @return sorted user list
     */
    public static SortedSet getAdminUserSet(SortedSet sortedSet) {

        ArrayList<User> userList = new ArrayList<>();

        String orderBy = "";
        if (sortedSet.getOrderByField() != null && !sortedSet.getOrderByField().trim().equals("")) {
            orderBy = "order by " + sortedSet.getOrderByField() + " " + sortedSet.getOrderByDirection();
        }
        String sql = "select * from  users where enabled=true and user_type like '" + User.ADMINISTRATOR + "' " + orderBy;

        Connection con = null;
        try {
            con = DBUtils.getConn();
            PreparedStatement stmt = con.prepareStatement(sql);
            ResultSet rs = stmt.executeQuery();
            while (rs.next()) {
                User user = new User();
                user.setId(rs.getLong("id"));
                user.setFirstNm(rs.getString("first_nm"));
                user.setLastNm(rs.getString("last_nm"));
                user.setEmail(rs.getString("email"));
                user.setUsername(rs.getString("username"));
                user.setPassword(rs.getString("password"));
                user.setAuthType(rs.getString("auth_type"));
                user.setUserType(rs.getString("user_type"));
                userList.add(user);

            }
            DBUtils.closeRs(rs);
            DBUtils.closeStmt(stmt);

        } catch (Exception e) {
            log.error(e.toString(), e);
        }
        DBUtils.closeConn(con);

        sortedSet.setItemList(userList);
        return sortedSet;
    }

    /**
     * returns all admin users based on sort order defined
     * @param sortedSet object that defines sort order
     * @return sorted user list
     */
    public static SortedSet getAdminUserSet(SortedSet sortedSet) {

        ArrayList<User> userList = new ArrayList<User>();

        String orderBy = "";
        if (sortedSet.getOrderByField() != null && !sortedSet.getOrderByField().trim().equals("")) {
            orderBy = "order by " + sortedSet.getOrderByField() + " " + sortedSet.getOrderByDirection();
        }
        String sql = "select * from  users where enabled=true and user_type like '" + User.ADMINISTRATOR + "' " + orderBy;

        Connection con = null;
        try {
            con = DBUtils.getConn();
            PreparedStatement stmt = con.prepareStatement(sql);
            ResultSet rs = stmt.executeQuery();
            while (rs.next()) {
                User user = new User();
                user.setId(rs.getLong("id"));
                user.setFirstNm(rs.getString("first_nm"));
                user.setLastNm(rs.getString("last_nm"));
                user.setEmail(rs.getString("email"));
                user.setUsername(rs.getString("username"));
                user.setPassword(rs.getString("password"));
                user.setAuthType(rs.getString("auth_type"));
                user.setUserType(rs.getString("user_type"));
                userList.add(user);

            }
            DBUtils.closeRs(rs);
            DBUtils.closeStmt(stmt);

        } catch (Exception e) {
            log.error(e.toString(), e);
        }
        DBUtils.closeConn(con);

        sortedSet.setItemList(userList);
        return sortedSet;
    }

Replace Generic With Diamond ArrayList<User> with ArrayList<> in method public getAdminUserSet(sortedSet SortedSet) : SortedSet from class com.keybox.manage.db.UserDB


    /**
     * return a list of profiles for user
     * @param userId user id
     * @return profile list
     */
    public static List<Profile> getProfilesByUser(Long userId) {

        Connection con = null;
        List<Profile> profileList = new ArrayList<>();
        try {
            con = DBUtils.getConn();
            profileList = getProfilesByUser(con, userId);

        } catch (Exception e) {
            log.error(e.toString(), e);
        }
        DBUtils.closeConn(con);
        return profileList;

    }

    /**
     * return a list of profiles for user
     * @param userId user id
     * @return profile list
     */
    public static List<Profile> getProfilesByUser(Long userId) {

        Connection con = null;
        List<Profile> profileList = new ArrayList<Profile>();
        try {
            con = DBUtils.getConn();
            profileList = getProfilesByUser(con, userId);

        } catch (Exception e) {
            log.error(e.toString(), e);
        }
        DBUtils.closeConn(con);
        return profileList;

    }

Replace Generic With Diamond ArrayList<Profile> with ArrayList<> in method public getProfilesByUser(userId Long) : List<Profile> from class com.keybox.manage.db.UserProfileDB


    /**
     * return a list of profiles for user
     * @param userId user id
     * @return profile list
     */
    public static List<Profile> getProfilesByUser(Connection con, Long userId) {

        ArrayList<Profile> profileList = new ArrayList<>();

        try {
            PreparedStatement stmt = con.prepareStatement("select * from  profiles g, user_map m where g.id=m.profile_id and m.user_id=? order by nm asc");
            stmt.setLong(1, userId);
            ResultSet rs = stmt.executeQuery();

            while (rs.next()) {
                Profile profile = new Profile();
                profile.setId(rs.getLong("id"));
                profile.setNm(rs.getString("nm"));
                profile.setDesc(rs.getString("desc"));
                profileList.add(profile);
            }
            DBUtils.closeRs(rs);
            DBUtils.closeStmt(stmt);

        } catch (Exception e) {
            log.error(e.toString(), e);
        }

        return profileList;
    }

    /**
     * return a list of profiles for user
     * @param userId user id
     * @return profile list
     */
    public static List<Profile> getProfilesByUser(Connection con, Long userId) {

        ArrayList<Profile> profileList = new ArrayList<Profile>();

        try {
            PreparedStatement stmt = con.prepareStatement("select * from  profiles g, user_map m where g.id=m.profile_id and m.user_id=? order by nm asc");
            stmt.setLong(1, userId);
            ResultSet rs = stmt.executeQuery();

            while (rs.next()) {
                Profile profile = new Profile();
                profile.setId(rs.getLong("id"));
                profile.setNm(rs.getString("nm"));
                profile.setDesc(rs.getString("desc"));
                profileList.add(profile);
            }
            DBUtils.closeRs(rs);
            DBUtils.closeStmt(stmt);

        } catch (Exception e) {
            log.error(e.toString(), e);
        }

        return profileList;
    }

Replace Generic With Diamond ArrayList<Profile> with ArrayList<> in method public getProfilesByUser(con Connection, userId Long) : List<Profile> from class com.keybox.manage.db.UserProfileDB


    /**
     * get users associated with profile
     * @param profileId profile id
     * @return user list
     */
    public static List<User> getUsersByProfile(Long profileId) {

        Connection con = null;
        List<User> userList = new ArrayList<>();
        try {
            con = DBUtils.getConn();
            userList = getUsersByProfile(con, profileId);

        } catch (Exception e) {
            log.error(e.toString(), e);
        }
        DBUtils.closeConn(con);
        return userList;

    }

    /**
     * get users associated with profile
     * @param profileId profile id
     * @return user list
     */
    public static List<User> getUsersByProfile(Long profileId) {

        Connection con = null;
        List<User> userList = new ArrayList<User>();
        try {
            con = DBUtils.getConn();
            userList = getUsersByProfile(con, profileId);

        } catch (Exception e) {
            log.error(e.toString(), e);
        }
        DBUtils.closeConn(con);
        return userList;

    }

Replace Generic With Diamond ArrayList<User> with ArrayList<> in method public getUsersByProfile(profileId Long) : List<User> from class com.keybox.manage.db.UserProfileDB


    /**
     * get users associated with profile
     * @param con DB connection
     * @param profileId profile id
     * @return user list
     */
    public static List<User> getUsersByProfile(Connection con, Long profileId) {

        ArrayList<User> userList = new ArrayList<>();

        try {
            PreparedStatement stmt = con.prepareStatement("select * from  users u, user_map m where u.id=m.user_id and m.profile_id=? order by last_nm asc");
            stmt.setLong(1, profileId);
            ResultSet rs = stmt.executeQuery();

            while (rs.next()) {
                User user = new User();
                user.setId(rs.getLong("id"));
                user.setFirstNm(rs.getString("first_nm"));
                user.setLastNm(rs.getString("last_nm"));
                user.setEmail(rs.getString("email"));
                user.setUsername(rs.getString("username"));
                user.setPassword(rs.getString("password"));
                userList.add(user);
            }
            DBUtils.closeRs(rs);
            DBUtils.closeStmt(stmt);

        } catch (Exception e) {
            log.error(e.toString(), e);
        }

        return userList;
    }

    /**
     * get users associated with profile
     * @param con DB connection
     * @param profileId profile id
     * @return user list
     */
    public static List<User> getUsersByProfile(Connection con, Long profileId) {

        ArrayList<User> userList = new ArrayList<User>();

        try {
            PreparedStatement stmt = con.prepareStatement("select * from  users u, user_map m where u.id=m.user_id and m.profile_id=? order by last_nm asc");
            stmt.setLong(1, profileId);
            ResultSet rs = stmt.executeQuery();

            while (rs.next()) {
                User user = new User();
                user.setId(rs.getLong("id"));
                user.setFirstNm(rs.getString("first_nm"));
                user.setLastNm(rs.getString("last_nm"));
                user.setEmail(rs.getString("email"));
                user.setUsername(rs.getString("username"));
                user.setPassword(rs.getString("password"));
                userList.add(user);
            }
            DBUtils.closeRs(rs);
            DBUtils.closeStmt(stmt);

        } catch (Exception e) {
            log.error(e.toString(), e);
        }

        return userList;
    }

Replace Generic With Diamond ArrayList<User> with ArrayList<> in method public getUsersByProfile(con Connection, profileId Long) : List<User> from class com.keybox.manage.db.UserProfileDB


	/**
	 * generates system's public/private key par and returns passphrase
	 *
	 * @return passphrase for system generated key
	 */
	public static String keyGen() {

		//get passphrase cmd from properties file
		Map<String, String> replaceMap = new HashMap<>();
		replaceMap.put("randomPassphrase", UUID.randomUUID().toString());

		String passphrase = AppConfig.getProperty("defaultSSHPassphrase", replaceMap);

		AppConfig.updateProperty("defaultSSHPassphrase", "${randomPassphrase}");

		return keyGen(passphrase);

	}

	/**
	 * generates system's public/private key par and returns passphrase
	 *
	 * @return passphrase for system generated key
	 */
	public static String keyGen() {

		//get passphrase cmd from properties file
		Map<String, String> replaceMap = new HashMap<String, String>();
		replaceMap.put("randomPassphrase", UUID.randomUUID().toString());

		String passphrase = AppConfig.getProperty("defaultSSHPassphrase", replaceMap);

		AppConfig.updateProperty("defaultSSHPassphrase", "${randomPassphrase}");

		return keyGen(passphrase);

	}

Replace Generic With Diamond HashMap<String,String> with HashMap<> in method public keyGen() : String from class com.keybox.manage.util.SSHUtil


    /**
     * returns list of output lines
     *
     * @param sessionId session id object
     * @param user user auth object
     * @return session output list
     */
    public static List<SessionOutput> getOutput(Connection con, Long sessionId, User user) {
        List<SessionOutput> outputList = new ArrayList<>();

        UserSessionsOutput userSessionsOutput = userSessionsOutputMap.get(sessionId);
        if (userSessionsOutput != null) {

            for (Integer key : userSessionsOutput.getSessionOutputMap().keySet()) {

                //get output chars and set to output
                try {
                    SessionOutput sessionOutput = userSessionsOutput.getSessionOutputMap().get(key);
                    if (sessionOutput!=null && sessionOutput.getOutput() != null) {

                        if (StringUtils.isNotEmpty(sessionOutput.getOutput())) {
                            outputList.add(sessionOutput);

                            //send to audit logger
                            systemAuditLogger.info(gson.toJson(new AuditWrapper(user, sessionOutput)));

                            if(enableInternalAudit) {
                                SessionAuditDB.insertTerminalLog(con, sessionOutput);
                            }

                            userSessionsOutput.getSessionOutputMap().put(key, new SessionOutput(sessionId, sessionOutput));
                        }
                    }
                } catch (Exception ex) {
                    log.error(ex.toString(), ex);
                }

            }

        }

        return outputList;
    }

    /**
     * returns list of output lines
     *
     * @param sessionId session id object
     * @param user user auth object
     * @return session output list
     */
    public static List<SessionOutput> getOutput(Connection con, Long sessionId, User user) {
        List<SessionOutput> outputList = new ArrayList<SessionOutput>();

        UserSessionsOutput userSessionsOutput = userSessionsOutputMap.get(sessionId);
        if (userSessionsOutput != null) {

            for (Integer key : userSessionsOutput.getSessionOutputMap().keySet()) {

                //get output chars and set to output
                try {
                    SessionOutput sessionOutput = userSessionsOutput.getSessionOutputMap().get(key);
                    if (sessionOutput!=null && sessionOutput.getOutput() != null) {

                        if (StringUtils.isNotEmpty(sessionOutput.getOutput())) {
                            outputList.add(sessionOutput);

                            //send to audit logger
                            systemAuditLogger.info(gson.toJson(new AuditWrapper(user, sessionOutput)));

                            if(enableInternalAudit) {
                                SessionAuditDB.insertTerminalLog(con, sessionOutput);
                            }

                            userSessionsOutput.getSessionOutputMap().put(key, new SessionOutput(sessionId, sessionOutput));
                        }
                    }
                } catch (Exception ex) {
                    log.error(ex.toString(), ex);
                }

            }

        }

        return outputList;
    }

Replace Generic With Diamond ArrayList<SessionOutput> with ArrayList<> in method public getOutput(con Connection, sessionId Long, user User) : List<SessionOutput> from class com.keybox.manage.util.SessionOutputUtil


	/**
	 * Load the file with the versions, used to check if the other files need conversion.
	 */
	@SuppressWarnings("unchecked")
	public void loadVersions() {
		File file = new File(versionPath);
		if(file.exists()) {
			// Load versions from the file
			try (ObjectInputStream input = new ObjectInputStream(new FileInputStream(versionPath))) {
				versions = (HashMap<String, Integer>) input.readObject();
			} catch(IOException | ClassNotFoundException | ClassCastException e) {
				AreaShop.warn("Something went wrong reading file: " + versionPath);
				versions = null;
			}
		}
		if(versions == null || versions.isEmpty()) {
			versions = new HashMap<>();
			versions.put(AreaShop.versionFiles, 0);
			this.saveVersions();
		}
	}

	/**
	 * Load the file with the versions, used to check if the other files need conversion.
	 */
	@SuppressWarnings("unchecked")
	public void loadVersions() {
		File file = new File(versionPath);
		if(file.exists()) {
			// Load versions from the file
			try {
				ObjectInputStream input = new ObjectInputStream(new FileInputStream(versionPath));
				versions = (HashMap<String, Integer>)input.readObject();
				input.close();
			} catch(IOException | ClassNotFoundException | ClassCastException e) {
				AreaShop.warn("Something went wrong reading file: " + versionPath);
				versions = null;
			}
		}
		if(versions == null || versions.size() == 0) {
			versions = new HashMap<>();
			versions.put(AreaShop.versionFiles, 0);
			this.saveVersions();
		}
	}

Try With Resources try(ObjectInputStream input=new ObjectInputStream(new FileInputStream(versionPath))) in method public loadVersions() : void from class me.wiefferink.areashop.managers.FileManager


	/**
	 * Save the versions file to disk.
	 */
	public void saveVersions() {
		if(!(new File(versionPath).exists())) {
			AreaShop.debug("versions file created, this should happen only after installing or upgrading the plugin");
		}
		try (ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream(versionPath))) {
			output.writeObject(versions);
		} catch(IOException e) {
			AreaShop.warn("File could not be saved: " + versionPath);
		}
	}

	/**
	 * Save the versions file to disk.
	 */
	public void saveVersions() {
		if(!(new File(versionPath).exists())) {
			AreaShop.debug("versions file created, this should happen only after installing or upgrading the plugin");
		}
		try {
			ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream(versionPath));
			output.writeObject(versions);
			output.close();
		} catch(IOException e) {
			AreaShop.warn("File could not be saved: " + versionPath);
		}
	}

Try With Resources try(ObjectOutputStream output=new ObjectOutputStream(new FileOutputStream(versionPath))) in method public saveVersions() : void from class me.wiefferink.areashop.managers.FileManager


	@Override
	public void execute(final CommandSender sender, final String[] args) {
		if(!sender.hasPermission("areashop.createrent")
				&& !sender.hasPermission("areashop.createrent.member")
				&& !sender.hasPermission("areashop.createrent.owner")

				&& !sender.hasPermission("areashop.createbuy")
				&& !sender.hasPermission("areashop.createbuy.member")
				&& !sender.hasPermission("areashop.createbuy.owner")) {
			plugin.message(sender, "add-noPermission");
			return;
		}

		if(args.length < 2 || args[1] == null || (!"rent".equals(args[1].toLowerCase()) && !"buy".equals(args[1].toLowerCase()))) {
			plugin.message(sender, "add-help");
			return;
		}
		List<ProtectedRegion> regions = new ArrayList<>();
		World world;
		Player player = null;
		if(sender instanceof Player) {
			player = (Player)sender;
		}
		if(args.length == 2) {
			if(player == null) {
				plugin.message(sender, "cmd-weOnlyByPlayer");
				return;
			}
			Selection selection = plugin.getWorldEdit().getSelection(player);
			if(selection == null) {
				plugin.message(player, "cmd-noSelection");
				return;
			}
			world = selection.getWorld();
			regions = Utils.getWorldEditRegionsInSelection(selection);
			if(regions.size() == 0) {
				plugin.message(player, "cmd-noWERegionsFound");
				return;
			}
		} else {
			if(player != null) {
				if(args.length == 4) {
					world = Bukkit.getWorld(args[3]);
					if(world == null) {
						plugin.message(sender, "add-incorrectWorld", args[3]);
						return;
					}
				} else {
					world = ((Player)sender).getWorld();
				}
			} else {
				if(args.length < 4) {
					plugin.message(sender, "add-specifyWorld");
					return;
				} else {
					world = Bukkit.getWorld(args[3]);
					if(world == null) {
						plugin.message(sender, "add-incorrectWorld", args[3]);
						return;
					}
				}
			}
			ProtectedRegion region = plugin.getWorldGuard().getRegionManager(world).getRegion(args[2]);
			if(region == null) {
				plugin.message(sender, "cmd-noRegion", args[2]);
				return;
			}
			regions.add(region);
		}
		final boolean isRent = "rent".equals(args[1].toLowerCase());
		final List<ProtectedRegion> finalRegions = regions;
		final Player finalPlayer = player;
		final World finalWorld = world;
		AreaShop.debug("Starting add task with " + regions.size() + " regions");

		TreeSet<GeneralRegion> regionsSuccess = new TreeSet<>();
		TreeSet<GeneralRegion> regionsAlready = new TreeSet<>();
		TreeSet<String> namesBlacklisted = new TreeSet<>();
		TreeSet<String> namesNoPermission = new TreeSet<>();
		Do.forAll(
			plugin.getConfig().getInt("adding.regionsPerTick"),
			regions,
			region -> {
				// Determine if the player is an owner or member of the region
				boolean isMember = finalPlayer != null && plugin.getWorldGuardHandler().containsMember(region, finalPlayer.getUniqueId());
				boolean isOwner = finalPlayer != null && plugin.getWorldGuardHandler().containsMember(region, finalPlayer.getUniqueId());
				String type;
				if(isRent) {
					type = "rent";
				} else {
					type = "buy";
				}
				FileManager.AddResult result = plugin.getFileManager().checkRegionAdd(sender, region, isRent ? GeneralRegion.RegionType.RENT : GeneralRegion.RegionType.BUY);
				if(result == FileManager.AddResult.ALREADYADDED) {
					regionsAlready.add(plugin.getFileManager().getRegion(region.getId()));
				} else if(result == FileManager.AddResult.BLACKLISTED) {
					namesBlacklisted.add(region.getId());
				} else if(result == FileManager.AddResult.NOPERMISSION) {
					namesNoPermission.add(region.getId());
				} else {
					// Check if the player should be landlord
					boolean landlord = (!sender.hasPermission("areashop.create" + type)
							&& ((sender.hasPermission("areashop.create" + type + ".owner") && isOwner)
							|| (sender.hasPermission("areashop.create" + type + ".member") && isMember)));
					List<UUID> existing = new ArrayList<>();
					existing.addAll(plugin.getWorldGuardHandler().getOwners(region).asUniqueIdList());
					existing.addAll(plugin.getWorldGuardHandler().getMembers(region).asUniqueIdList());
					if(isRent) {
						RentRegion rent = new RentRegion(region.getId(), finalWorld);
						// Set landlord
						if(landlord) {
							rent.setLandlord(finalPlayer.getUniqueId(), finalPlayer.getName());
						}
						// Run commands
						rent.runEventCommands(GeneralRegion.RegionEvent.CREATED, true);
						plugin.getFileManager().addRent(rent);
						rent.handleSchematicEvent(GeneralRegion.RegionEvent.CREATED);

						rent.update();

						// Run commands
						rent.runEventCommands(GeneralRegion.RegionEvent.CREATED, false);

						// Add existing owners/members if any
						if(!landlord && !existing.isEmpty()) {
							// TODO also execute rent events to notify other plugins?

							// Run commands
							rent.runEventCommands(GeneralRegion.RegionEvent.RENTED, true);

							// Add values to the rent and send it to FileManager
							rent.setRentedUntil(Calendar.getInstance().getTimeInMillis() + rent.getDuration());
							rent.setRenter(existing.remove(0));
							rent.updateLastActiveTime();

							// Add others as friends
							for(UUID friend : existing) {
								rent.getFriendsFeature().addFriend(friend, null);
							}

							// Fire schematic event and updated times extended
							rent.handleSchematicEvent(GeneralRegion.RegionEvent.RENTED);

							// Notify about updates
							rent.update();

							rent.runEventCommands(GeneralRegion.RegionEvent.RENTED, false);
						}

						regionsSuccess.add(rent);
					} else {
						BuyRegion buy = new BuyRegion(region.getId(), finalWorld);
						// Set landlord
						if(landlord) {
							buy.setLandlord(finalPlayer.getUniqueId(), finalPlayer.getName());
						}
						// Run commands
						buy.runEventCommands(GeneralRegion.RegionEvent.CREATED, true);

						plugin.getFileManager().addBuy(buy);
						buy.handleSchematicEvent(GeneralRegion.RegionEvent.CREATED);

						buy.update();

						// Run commands
						buy.runEventCommands(GeneralRegion.RegionEvent.CREATED, false);

						// Add existing owners/members if any
						if(!landlord && !existing.isEmpty()) {
							// TODO also execute buy events to notify for other plugins?

							// Run commands
							buy.runEventCommands(GeneralRegion.RegionEvent.BOUGHT, true);

							// Set the owner
							buy.setBuyer(existing.remove(0));
							buy.updateLastActiveTime();
							// Add others as friends
							for(UUID friend : existing) {
								buy.getFriendsFeature().addFriend(friend, null);
							}

							// Notify about updates
							buy.update();

							// Update everything
							buy.handleSchematicEvent(GeneralRegion.RegionEvent.BOUGHT);

							// Run commands
							buy.runEventCommands(GeneralRegion.RegionEvent.BOUGHT, false);
						}

						regionsSuccess.add(buy);
					}
				}
			},
			() -> {
				if(!regionsSuccess.isEmpty()) {
					plugin.message(sender, "add-success", args[1], Utils.combinedMessage(regionsSuccess, "region"));
				}
				if(!regionsAlready.isEmpty()) {
					plugin.message(sender, "add-failed", Utils.combinedMessage(regionsAlready, "region"));
				}
				if(!namesBlacklisted.isEmpty()) {
					plugin.message(sender, "add-blacklisted", Utils.createCommaSeparatedList(namesBlacklisted));
				}
				if(!namesNoPermission.isEmpty()) {
					plugin.message(sender, "add-noPermissionRegions", Utils.createCommaSeparatedList(namesNoPermission));
					plugin.message(sender, "add-noPermissionOwnerMember");
				}
			}
		);
	}

	@Override
	public void execute(final CommandSender sender, final String[] args) {
		if(!sender.hasPermission("areashop.createrent")
				&& !sender.hasPermission("areashop.createrent.member")
				&& !sender.hasPermission("areashop.createrent.owner")

				&& !sender.hasPermission("areashop.createbuy")
				&& !sender.hasPermission("areashop.createbuy.member")
				&& !sender.hasPermission("areashop.createbuy.owner")) {
			plugin.message(sender, "add-noPermission");
			return;
		}

		if(args.length < 2 || args[1] == null || (!"rent".equals(args[1].toLowerCase()) && !"buy".equals(args[1].toLowerCase()))) {
			plugin.message(sender, "add-help");
			return;
		}
		List<ProtectedRegion> regions = new ArrayList<>();
		World world;
		Player player = null;
		if(sender instanceof Player) {
			player = (Player)sender;
		}
		if(args.length == 2) {
			if(player == null) {
				plugin.message(sender, "cmd-weOnlyByPlayer");
				return;
			}
			Selection selection = plugin.getWorldEdit().getSelection(player);
			if(selection == null) {
				plugin.message(player, "cmd-noSelection");
				return;
			}
			world = selection.getWorld();
			regions = Utils.getWorldEditRegionsInSelection(selection);
			if(regions.size() == 0) {
				plugin.message(player, "cmd-noWERegionsFound");
				return;
			}
		} else {
			if(player != null) {
				if(args.length == 4) {
					world = Bukkit.getWorld(args[3]);
					if(world == null) {
						plugin.message(sender, "add-incorrectWorld", args[3]);
						return;
					}
				} else {
					world = ((Player)sender).getWorld();
				}
			} else {
				if(args.length < 4) {
					plugin.message(sender, "add-specifyWorld");
					return;
				} else {
					world = Bukkit.getWorld(args[3]);
					if(world == null) {
						plugin.message(sender, "add-incorrectWorld", args[3]);
						return;
					}
				}
			}
			ProtectedRegion region = plugin.getWorldGuard().getRegionManager(world).getRegion(args[2]);
			if(region == null) {
				plugin.message(sender, "cmd-noRegion", args[2]);
				return;
			}
			regions.add(region);
		}
		final boolean isRent = "rent".equals(args[1].toLowerCase());
		final List<ProtectedRegion> finalRegions = regions;
		final Player finalPlayer = player;
		final World finalWorld = world;
		AreaShop.debug("Starting add task with " + regions.size() + " regions");
		new BukkitRunnable() {
			private int current = 0;
			private TreeSet<GeneralRegion> regionsSuccess = new TreeSet<>();
			private TreeSet<GeneralRegion> regionsAlready = new TreeSet<>();
			private TreeSet<String> namesBlacklisted = new TreeSet<>();
			private TreeSet<String> namesNoPermission = new TreeSet<>();

			@Override
			public void run() {
				for(int i = 0; i < plugin.getConfig().getInt("adding.regionsPerTick"); i++) {
					if(current < finalRegions.size()) {
						ProtectedRegion region = finalRegions.get(current);
						// Determine if the player is an owner or member of the region
						boolean isMember = finalPlayer != null && plugin.getWorldGuardHandler().containsMember(region, finalPlayer.getUniqueId());
						boolean isOwner = finalPlayer != null && plugin.getWorldGuardHandler().containsMember(region, finalPlayer.getUniqueId());
						String type;
						if(isRent) {
							type = "rent";
						} else {
							type = "buy";
						}
						FileManager.AddResult result = plugin.getFileManager().checkRegionAdd(sender, region, isRent ? GeneralRegion.RegionType.RENT : GeneralRegion.RegionType.BUY);
						if(result == FileManager.AddResult.ALREADYADDED) {
							regionsAlready.add(plugin.getFileManager().getRegion(region.getId()));
						} else if(result == FileManager.AddResult.BLACKLISTED) {
							namesBlacklisted.add(region.getId());
						} else if(result == FileManager.AddResult.NOPERMISSION) {
							namesNoPermission.add(region.getId());
						} else {
							// Check if the player should be landlord
							boolean landlord = (!sender.hasPermission("areashop.create" + type)
									&& ((sender.hasPermission("areashop.create" + type + ".owner") && isOwner)
									|| (sender.hasPermission("areashop.create" + type + ".member") && isMember)));
							List<UUID> existing = new ArrayList<>();
							existing.addAll(plugin.getWorldGuardHandler().getOwners(region).asUniqueIdList());
							existing.addAll(plugin.getWorldGuardHandler().getMembers(region).asUniqueIdList());
							if(isRent) {
								RentRegion rent = new RentRegion(region.getId(), finalWorld);
								// Set landlord
								if(landlord) {
									rent.setLandlord(finalPlayer.getUniqueId(), finalPlayer.getName());
								}
								// Run commands
								rent.runEventCommands(GeneralRegion.RegionEvent.CREATED, true);
								plugin.getFileManager().addRent(rent);
								rent.handleSchematicEvent(GeneralRegion.RegionEvent.CREATED);

								rent.update();

								// Run commands
								rent.runEventCommands(GeneralRegion.RegionEvent.CREATED, false);

								// Add existing owners/members if any
								if(!landlord && !existing.isEmpty()) {
									// TODO also execute rent events to notify other plugins?

									// Run commands
									rent.runEventCommands(GeneralRegion.RegionEvent.RENTED, true);

									// Add values to the rent and send it to FileManager
									rent.setRentedUntil(Calendar.getInstance().getTimeInMillis() + rent.getDuration());
									rent.setRenter(existing.remove(0));
									rent.updateLastActiveTime();

									// Add others as friends
									for(UUID friend : existing) {
										rent.getFriendsFeature().addFriend(friend, null);
									}

									// Fire schematic event and updated times extended
									rent.handleSchematicEvent(GeneralRegion.RegionEvent.RENTED);

									// Notify about updates
									rent.update();

									rent.runEventCommands(GeneralRegion.RegionEvent.RENTED, false);
								}

								regionsSuccess.add(rent);
							} else {
								BuyRegion buy = new BuyRegion(region.getId(), finalWorld);
								// Set landlord
								if(landlord) {
									buy.setLandlord(finalPlayer.getUniqueId(), finalPlayer.getName());
								}
								// Run commands
								buy.runEventCommands(GeneralRegion.RegionEvent.CREATED, true);

								plugin.getFileManager().addBuy(buy);
								buy.handleSchematicEvent(GeneralRegion.RegionEvent.CREATED);

								buy.update();

								// Run commands
								buy.runEventCommands(GeneralRegion.RegionEvent.CREATED, false);

								// Add existing owners/members if any
								if(!landlord && !existing.isEmpty()) {
									// TODO also execute buy events to notify for other plugins?

									// Run commands
									buy.runEventCommands(GeneralRegion.RegionEvent.BOUGHT, true);

									// Set the owner
									buy.setBuyer(existing.remove(0));
									buy.updateLastActiveTime();
									// Add others as friends
									for(UUID friend : existing) {
										buy.getFriendsFeature().addFriend(friend, null);
									}

									// Notify about updates
									buy.update();

									// Update everything
									buy.handleSchematicEvent(GeneralRegion.RegionEvent.BOUGHT);

									// Run commands
									buy.runEventCommands(GeneralRegion.RegionEvent.BOUGHT, false);
								}

								regionsSuccess.add(buy);
							}
						}
						current++;
					}
				}
				if(current >= finalRegions.size()) {
					if(!regionsSuccess.isEmpty()) {
						plugin.message(sender, "add-success", args[1], Utils.combinedMessage(regionsSuccess, "region"));
					}
					if(!regionsAlready.isEmpty()) {
						plugin.message(sender, "add-failed", Utils.combinedMessage(regionsAlready, "region"));
					}
					if(!namesBlacklisted.isEmpty()) {
						plugin.message(sender, "add-blacklisted", Utils.createCommaSeparatedList(namesBlacklisted));
					}
					if(!namesNoPermission.isEmpty()) {
						plugin.message(sender, "add-noPermissionRegions", Utils.createCommaSeparatedList(namesNoPermission));
						plugin.message(sender, "add-noPermissionOwnerMember");
					}
					this.cancel();
				}
			}
		}.runTaskTimer(plugin, 1, 1);
	}

Replace Anonymous With Lambda me.wiefferink.areashop.commands.AddCommand.execute.runTaskTimer.new BukkitRunnable with region -> {boolean isMember=finalPlayer != null && plugin.getWorldGuardHandler().containsMember(region,finalPlayer.getUniqueId()); in method public execute(sender CommandSender, args String[]) : void from class me.wiefferink.areashop.commands.AddCommand


	/**
	 * Called when a sign is changed.
	 * @param event The event
	 */
	@EventHandler(priority = EventPriority.MONITOR)
	public void onPlayerLogin(PlayerLoginEvent event) {
		if(event.getResult() != Result.ALLOWED) {
			return;
		}
		final Player player = event.getPlayer();

		// Schedule task to check for notifications, prevents a lag spike at login
		Do.syncTimerLater(25, 25, () -> {
			// Delay until all regions are loaded
			if(!plugin.isReady()) {
				return true;
			}
			if(!player.isOnline()) {
				return false;
			}
			// Notify for rents that almost run out
			for(RentRegion region : plugin.getFileManager().getRents()) {
				if(region.isRenter(player)) {
					String warningSetting = region.getStringSetting("rent.warningOnLoginTime");
					if(warningSetting == null || warningSetting.isEmpty()) {
						continue;
					}
					long warningTime = Utils.durationStringToLong(warningSetting);
					if(region.getTimeLeft() < warningTime) {
						// Send the warning message later to let it appear after general MOTD messages
						AreaShop.getInstance().message(player, "rent-expireWarning", region);
					}
				}
			}

			// Notify admins for plugin updates
			AreaShop.getInstance().notifyUpdate(player);
			return false;
		});

		// Check if the player has regions that use an old name of him and update them
		Do.syncTimerLater(22, 10, () -> {
			if(!plugin.isReady()) {
				return true;
			}

			List<GeneralRegion> regions = new ArrayList<>();
			for(GeneralRegion region : plugin.getFileManager().getRegions()) {
				if(region.isOwner(player)) {
					regions.add(region);
				}
			}

			Do.forAll(
				plugin.getConfig().getInt("nameupdate.regionsPerTick"),
				regions,
				region -> {
					if(region instanceof BuyRegion) {
						if(!player.getName().equals(region.getStringSetting("buy.buyerName"))) {
							region.setSetting("buy.buyerName", player.getName());
							region.update();
						}
					} else if(region instanceof RentRegion) {
						if(!player.getName().equals(region.getStringSetting("rent.renterName"))) {
							region.setSetting("rent.renterName", player.getName());
							region.update();
						}
					}
				}
			);
			return false;
		});
	}

	/**
	 * Called when a sign is changed.
	 * @param event The event
	 */
	@EventHandler(priority = EventPriority.MONITOR)
	public void onPlayerLogin(PlayerLoginEvent event) {
		if(event.getResult() != Result.ALLOWED) {
			return;
		}
		final Player player = event.getPlayer();

		// Schedule task to check for notifications, prevents a lag spike at login
		new BukkitRunnable() {
			@Override
			public void run() {
				// Delay until all regions are loaded
				if(!plugin.isReady()) {
					return;
				}
				if(!player.isOnline()) {
					this.cancel();
					return;
				}
				// Notify for rents that almost run out
				for(RentRegion region : plugin.getFileManager().getRents()) {
					if(region.isRenter(player)) {
						String warningSetting = region.getStringSetting("rent.warningOnLoginTime");
						if(warningSetting == null || warningSetting.isEmpty()) {
							continue;
						}
						long warningTime = Utils.durationStringToLong(warningSetting);
						if(region.getTimeLeft() < warningTime) {
							// Send the warning message later to let it appear after general MOTD messages
							AreaShop.getInstance().message(player, "rent-expireWarning", region);
						}
					}
				}

				// Notify admins for plugin updates
				AreaShop.getInstance().notifyUpdate(player);

				this.cancel();
			}
		}.runTaskTimer(plugin, 25, 25);

		// Check if the player has regions that use an old name of him and update them
		final List<GeneralRegion> regions = new ArrayList<>(plugin.getFileManager().getRegions());
		new BukkitRunnable() {
			private int current = 0;

			@Override
			public void run() {
				// Delay until all regions are loaded
				if(!plugin.isReady()) {
					return;
				}

				// Check all regions
				for(int i = 0; i < plugin.getConfig().getInt("nameupdate.regionsPerTick"); i++) {
					if(current < regions.size()) {
						GeneralRegion region = regions.get(current);
						if(region.isOwner(player)) {
							if(region instanceof BuyRegion) {
								if(!player.getName().equals(region.getStringSetting("buy.buyerName"))) {
									region.setSetting("buy.buyerName", player.getName());
									region.update();
								}
							} else if(region instanceof RentRegion) {
								if(!player.getName().equals(region.getStringSetting("rent.renterName"))) {
									region.setSetting("rent.renterName", player.getName());
									region.update();
								}
							}
						}
						current++;
					}
				}
				if(current >= regions.size()) {
					this.cancel();
				}
			}
		}.runTaskTimer(plugin, 22, 1); // Wait a bit before starting to prevent a lot of stress on the server when a player joins (a lot of plugins already do stuff then)
	}

Replace Anonymous With Lambda me.wiefferink.areashop.listeners.PlayerLoginLogoutListener.onPlayerLogin.runTaskTimer.new BukkitRunnable with () -> {if(!plugin.isReady()){return true; in method public onPlayerLogin(event PlayerLoginEvent) : void from class me.wiefferink.areashop.listeners.PlayerLoginLogoutListener


	/**
	 * Load all files from disk.
	 * @param thisTick Load files in the current tick or a tick later
	 * @return true if the files are loaded correctly, otherwise false
	 */
	public boolean loadFiles(boolean thisTick) {
		// Load config.yml + add defaults from .jar
		boolean result = loadConfigFile();
		// Load default.yml + add defaults from .jar
		result &= loadDefaultFile();
		// Convert old formats to the latest (object saving to .yml saving)
		preUpdateFiles();
		if(thisTick) {
			// Load region files (regions folder)
			loadRegionFiles();
			// Convert old formats to the latest (changes in .yml saving format)
			postUpdateFiles();
			// Load groups.yml
			result &= loadGroupsFile();
		} else {
			Do.sync(() -> {
				// Load region files (regions folder)
				loadRegionFiles();
				// Convert old formats to the latest (changes in .yml saving format)
				postUpdateFiles();
				// Load groups.yml
				loadGroupsFile();
			});
		}
		return result;
	}

	/**
	 * Load all files from disk.
	 * @param thisTick Load files in the current tick or a tick later
	 * @return true if the files are loaded correctly, otherwise false
	 */
	public boolean loadFiles(boolean thisTick) {
		// Load config.yml + add defaults from .jar
		boolean result = loadConfigFile();
		// Load default.yml + add defaults from .jar
		result &= loadDefaultFile();
		// Convert old formats to the latest (object saving to .yml saving)
		preUpdateFiles();
		if(thisTick) {
			// Load region files (regions folder)
			loadRegionFiles();
			// Convert old formats to the latest (changes in .yml saving format)
			postUpdateFiles();
			// Load groups.yml
			result &= loadGroupsFile();
		} else {
			new BukkitRunnable() {
				@Override
				public void run() {
					// Load region files (regions folder)
					loadRegionFiles();
					// Convert old formats to the latest (changes in .yml saving format)
					postUpdateFiles();
					// Load groups.yml
					loadGroupsFile();
				}
			}.runTask(plugin);
		}
		return result;
	}

Replace Anonymous With Lambda me.wiefferink.areashop.managers.FileManager.loadFiles.runTask.new BukkitRunnable with () -> {loadRegionFiles(); in method public loadFiles(thisTick boolean) : boolean from class me.wiefferink.areashop.managers.FileManager


	@Override
	public boolean restoreRegionBlocks(File file, GeneralRegionInterface regionInterface) {
		com.sk89q.worldedit.world.World world = null;
		if(regionInterface.getName() != null) {
			world = LocalWorldAdapter.adapt(new BukkitWorld(regionInterface.getWorld()));
		}
		if(world == null) {
			pluginInterface.getLogger().info("Did not restore region " + regionInterface.getName() + ", world not found: " + regionInterface.getWorldName());
			return false;
		}
		EditSession editSession = pluginInterface.getWorldEdit().getWorldEdit().getEditSessionFactory().getEditSession(world, pluginInterface.getConfig().getInt("maximumBlocks"));
		editSession.enableQueue();
		ProtectedRegion region = regionInterface.getRegion();
		// Get the origin and size of the region
		Vector origin = new Vector(region.getMinimumPoint().getBlockX(), region.getMinimumPoint().getBlockY(), region.getMinimumPoint().getBlockZ());

		// Read the schematic and paste it into the world
		try(Closer closer = Closer.create()) {
			FileInputStream fis = closer.register(new FileInputStream(file));
			BufferedInputStream bis = closer.register(new BufferedInputStream(fis));
			ClipboardReader reader = ClipboardFormat.SCHEMATIC.getReader(bis);

			WorldData worldData = world.getWorldData();
			LocalSession session = new LocalSession(pluginInterface.getWorldEdit().getLocalConfiguration());
			Clipboard clipboard = reader.read(worldData);
			if(clipboard.getDimensions().getY() != regionInterface.getHeight()
					|| clipboard.getDimensions().getX() != regionInterface.getWidth()
					|| clipboard.getDimensions().getZ() != regionInterface.getDepth()) {
				pluginInterface.getLogger().warning("Size of the region " + regionInterface.getName() + " is not the same as the schematic to restore!");
				pluginInterface.debugI("schematic|region, x:" + clipboard.getDimensions().getX() + "|" + regionInterface.getWidth() + ", y:" + clipboard.getDimensions().getY() + "|" + regionInterface.getHeight() + ", z:" + clipboard.getDimensions().getZ() + "|" + regionInterface.getDepth());
			}
			clipboard.setOrigin(clipboard.getMinimumPoint());
			ClipboardHolder clipboardHolder = new ClipboardHolder(clipboard, worldData);
			session.setBlockChangeLimit(pluginInterface.getConfig().getInt("maximumBlocks"));
			session.setClipboard(clipboardHolder);
			Operation operation = clipboardHolder
					.createPaste(editSession, editSession.getWorld().getWorldData())
					.to(origin)
					.build();
			Operations.completeLegacy(operation);
		} catch(MaxChangedBlocksException e) {
			pluginInterface.getLogger().warning("Exeeded the block limit while restoring schematic of " + regionInterface.getName() + ", limit in exception: " + e.getBlockLimit() + ", limit passed by AreaShop: " + pluginInterface.getConfig().getInt("maximumBlocks"));
			return false;
		} catch(IOException e) {
			pluginInterface.getLogger().warning("An error occured while restoring schematic of " + regionInterface.getName() + ", enable debug to see the complete stacktrace");
			pluginInterface.debugI(ExceptionUtils.getStackTrace(e));
			return false;
		}
		editSession.flushQueue();
		return true;
	}

	@Override
	public boolean restoreRegionBlocks(File file, GeneralRegionInterface regionInterface) {
		com.sk89q.worldedit.world.World world = null;
		if(regionInterface.getName() != null) {
			world = LocalWorldAdapter.adapt(new BukkitWorld(regionInterface.getWorld()));
		}
		if(world == null) {
			pluginInterface.getLogger().info("Did not restore region " + regionInterface.getName() + ", world not found: " + regionInterface.getWorldName());
			return false;
		}
		EditSession editSession = pluginInterface.getWorldEdit().getWorldEdit().getEditSessionFactory().getEditSession(world, pluginInterface.getConfig().getInt("maximumBlocks"));
		editSession.enableQueue();
		ProtectedRegion region = regionInterface.getRegion();
		// Get the origin and size of the region
		Vector origin = new Vector(region.getMinimumPoint().getBlockX(), region.getMinimumPoint().getBlockY(), region.getMinimumPoint().getBlockZ());

		// Read the schematic and paste it into the world
		Closer closer = Closer.create();
		try {
			FileInputStream fis = closer.register(new FileInputStream(file));
			BufferedInputStream bis = closer.register(new BufferedInputStream(fis));
			ClipboardReader reader = ClipboardFormat.SCHEMATIC.getReader(bis);

			WorldData worldData = world.getWorldData();
			LocalSession session = new LocalSession(pluginInterface.getWorldEdit().getLocalConfiguration());
			Clipboard clipboard = reader.read(worldData);
			if(clipboard.getDimensions().getY() != regionInterface.getHeight()
					|| clipboard.getDimensions().getX() != regionInterface.getWidth()
					|| clipboard.getDimensions().getZ() != regionInterface.getDepth()) {
				pluginInterface.getLogger().warning("Size of the region " + regionInterface.getName() + " is not the same as the schematic to restore!");
				pluginInterface.debugI("schematic|region, x:" + clipboard.getDimensions().getX() + "|" + regionInterface.getWidth() + ", y:" + clipboard.getDimensions().getY() + "|" + regionInterface.getHeight() + ", z:" + clipboard.getDimensions().getZ() + "|" + regionInterface.getDepth());
			}
			clipboard.setOrigin(clipboard.getMinimumPoint());
			ClipboardHolder clipboardHolder = new ClipboardHolder(clipboard, worldData);
			session.setBlockChangeLimit(pluginInterface.getConfig().getInt("maximumBlocks"));
			session.setClipboard(clipboardHolder);
			Operation operation = clipboardHolder
					.createPaste(editSession, editSession.getWorld().getWorldData())
					.to(origin)
					.build();
			Operations.completeLegacy(operation);
		} catch (MaxChangedBlocksException e) {
			pluginInterface.getLogger().warning("Exeeded the block limit while restoring schematic of "+regionInterface.getName()+", limit in exception: "+e.getBlockLimit()+", limit passed by AreaShop: "+pluginInterface.getConfig().getInt("maximumBlocks"));
			return false;
		} catch (IOException e) {
			pluginInterface.getLogger().warning("An error occured while restoring schematic of " + regionInterface.getName() + ", enable debug to see the complete stacktrace");
			pluginInterface.debugI(ExceptionUtils.getStackTrace(e));
			return false;
		} finally {
			try {
				closer.close();
			} catch (IOException ignored) {
			}
		}
		editSession.flushQueue();
		return true;
	}

Try With Resources try(Closer closer=Closer.create()) in method public restoreRegionBlocks(file File, regionInterface GeneralRegionInterface) : boolean from class me.wiefferink.areashop.handlers.WorldEditHandler6


	@Override
	public boolean saveRegionBlocks(File file, GeneralRegionInterface regionInterface) {
		com.sk89q.worldedit.world.World world = null;
		if(regionInterface.getWorld() != null) {
			world = LocalWorldAdapter.adapt(new BukkitWorld(regionInterface.getWorld()));
		}
		if(world == null) {
			pluginInterface.getLogger().warning("Did not save region " + regionInterface.getName() + ", world not found: " + regionInterface.getWorldName());
			return false;
		}
		EditSession editSession = pluginInterface.getWorldEdit().getWorldEdit().getEditSessionFactory().getEditSession(world, pluginInterface.getConfig().getInt("maximumBlocks"));
		// Create a clipboard
		CuboidRegion selection = new CuboidRegion(world, regionInterface.getRegion().getMinimumPoint(), regionInterface.getRegion().getMaximumPoint());
		BlockArrayClipboard clipboard = new BlockArrayClipboard(selection);
		clipboard.setOrigin(regionInterface.getRegion().getMinimumPoint());
		ForwardExtentCopy copy = new ForwardExtentCopy(editSession, new CuboidRegion(world, regionInterface.getRegion().getMinimumPoint(), regionInterface.getRegion().getMaximumPoint()), clipboard, regionInterface.getRegion().getMinimumPoint());
		try {
			Operations.completeLegacy(copy);
		} catch(MaxChangedBlocksException e) {
			pluginInterface.getLogger().warning("Exeeded the block limit while saving schematic of " + regionInterface.getName() + ", limit in exception: " + e.getBlockLimit() + ", limit passed by AreaShop: " + pluginInterface.getConfig().getInt("maximumBlocks"));
			return false;
		}

		try(Closer closer = Closer.create()) {
			FileOutputStream fos = closer.register(new FileOutputStream(file));
			BufferedOutputStream bos = closer.register(new BufferedOutputStream(fos));
			ClipboardWriter writer = closer.register(ClipboardFormat.SCHEMATIC.getWriter(bos));
			writer.write(clipboard, world.getWorldData());
		} catch(IOException e) {
			pluginInterface.getLogger().warning("An error occured while saving schematic of " + regionInterface.getName() + ", enable debug to see the complete stacktrace");
			pluginInterface.debugI(ExceptionUtils.getStackTrace(e));
			return false;
		}
		return true;
	}

	@Override
	public boolean saveRegionBlocks(File file, GeneralRegionInterface regionInterface) {
		com.sk89q.worldedit.world.World world = null;
		if(regionInterface.getWorld() != null) {
			world = LocalWorldAdapter.adapt(new BukkitWorld(regionInterface.getWorld()));
		}
		if(world == null) {
			pluginInterface.getLogger().warning("Did not save region " + regionInterface.getName() + ", world not found: " + regionInterface.getWorldName());
			return false;
		}
		EditSession editSession = pluginInterface.getWorldEdit().getWorldEdit().getEditSessionFactory().getEditSession(world, pluginInterface.getConfig().getInt("maximumBlocks"));
		// Create a clipboard
		CuboidRegion selection = new CuboidRegion(world, regionInterface.getRegion().getMinimumPoint(), regionInterface.getRegion().getMaximumPoint());
		BlockArrayClipboard clipboard = new BlockArrayClipboard(selection);
		clipboard.setOrigin(regionInterface.getRegion().getMinimumPoint());
		ForwardExtentCopy copy = new ForwardExtentCopy(editSession, new CuboidRegion(world, regionInterface.getRegion().getMinimumPoint(), regionInterface.getRegion().getMaximumPoint()), clipboard, regionInterface.getRegion().getMinimumPoint());
		try {
			Operations.completeLegacy(copy);
		} catch(MaxChangedBlocksException e) {
			pluginInterface.getLogger().warning("Exeeded the block limit while saving schematic of "+regionInterface.getName()+", limit in exception: "+e.getBlockLimit()+", limit passed by AreaShop: "+pluginInterface.getConfig().getInt("maximumBlocks"));
			return false;
		}
		Closer closer = Closer.create();
		try {
			FileOutputStream fos = closer.register(new FileOutputStream(file));
			BufferedOutputStream bos = closer.register(new BufferedOutputStream(fos));
			ClipboardWriter writer = closer.register(ClipboardFormat.SCHEMATIC.getWriter(bos));
			writer.write(clipboard, world.getWorldData());
		} catch (IOException e) {
			pluginInterface.getLogger().warning("An error occured while saving schematic of " + regionInterface.getName() + ", enable debug to see the complete stacktrace");
			pluginInterface.debugI(ExceptionUtils.getStackTrace(e));
			return false;
		} finally {
			try {
				closer.close();
			} catch (IOException ignored) {
			}
		}
		return true;
	}

Try With Resources try(Closer closer=Closer.create()) in method public saveRegionBlocks(file File, regionInterface GeneralRegionInterface) : boolean from class me.wiefferink.areashop.handlers.WorldEditHandler6


	@Override
	public boolean restoreRegionBlocks(File file, GeneralRegionInterface regionInterface) {
		boolean result = true;
		EditSession editSession = pluginInterface.getWorldEdit().getWorldEdit().getEditSessionFactory().getEditSession(new BukkitWorld(regionInterface.getWorld()), pluginInterface.getConfig().getInt("maximumBlocks"));
		// Get the origin and size of the region
		Vector origin = new Vector(regionInterface.getRegion().getMinimumPoint().getBlockX(), regionInterface.getRegion().getMinimumPoint().getBlockY(), regionInterface.getRegion().getMinimumPoint().getBlockZ());

		editSession.enableQueue();
		Exception otherException = null;
		try {
			CuboidClipboard clipBoard = SchematicFormat.MCEDIT.load(file);
			if(clipBoard.getHeight() != regionInterface.getHeight()
					|| clipBoard.getWidth() != regionInterface.getWidth()
					|| clipBoard.getLength() != regionInterface.getDepth()) {
				pluginInterface.getLogger().warning("Size of the region " + regionInterface.getName() + " is not the same as the schematic to restore!");
				pluginInterface.debugI("schematic|region, x:" + clipBoard.getWidth() + "|" + regionInterface.getWidth() + ", y:" + clipBoard.getHeight() + "|" + regionInterface.getHeight() + ", z:" + clipBoard.getLength() + "|" + regionInterface.getDepth());
			}
			clipBoard.place(editSession, origin, false);
		} catch(MaxChangedBlocksException e) {
			pluginInterface.getLogger().warning("Exeeded the block limit while restoring schematic of "+regionInterface.getName()+", limit in exception: "+e.getBlockLimit()+", limit passed by AreaShop: "+pluginInterface.getConfig().getInt("maximumBlocks"));
			result = false;
		} catch(DataException|IOException e) {
			otherException = e;
		}
		if(otherException != null) {
			pluginInterface.getLogger().warning("Failed to restore schematic for region " + regionInterface.getName());
			pluginInterface.debugI(ExceptionUtils.getStackTrace(otherException));
			result = false;
		}
		editSession.flushQueue();
		return result;
	}

	@Override
	public boolean restoreRegionBlocks(File file, GeneralRegionInterface regionInterface) {
		boolean result = true;
		EditSession editSession = pluginInterface.getWorldEdit().getWorldEdit().getEditSessionFactory().getEditSession(new BukkitWorld(regionInterface.getWorld()), pluginInterface.getConfig().getInt("maximumBlocks"));
		// Get the origin and size of the region
		Vector origin = new Vector(regionInterface.getRegion().getMinimumPoint().getBlockX(), regionInterface.getRegion().getMinimumPoint().getBlockY(), regionInterface.getRegion().getMinimumPoint().getBlockZ());

		editSession.enableQueue();
		Exception otherException = null;
		try {
			CuboidClipboard clipBoard = SchematicFormat.MCEDIT.load(file);
			if(clipBoard.getHeight() != regionInterface.getHeight()
					|| clipBoard.getWidth() != regionInterface.getWidth()
					|| clipBoard.getLength() != regionInterface.getDepth()) {
				pluginInterface.getLogger().warning("Size of the region " + regionInterface.getName() + " is not the same as the schematic to restore!");
				pluginInterface.debugI("schematic|region, x:" + clipBoard.getWidth() + "|" + regionInterface.getWidth() + ", y:" + clipBoard.getHeight() + "|" + regionInterface.getHeight() + ", z:" + clipBoard.getLength() + "|" + regionInterface.getDepth());
			}
			clipBoard.place(editSession, origin, false);
		} catch(MaxChangedBlocksException e) {
			pluginInterface.getLogger().warning("Exeeded the block limit while restoring schematic of " + regionInterface.getName());
			result = false;
		} catch(DataException e) {
			otherException = e;
		} catch(IOException e) {
			otherException = e;
		}
		if(otherException != null) {
			pluginInterface.getLogger().warning("Failed to restore schematic for region " + regionInterface.getName());
			pluginInterface.debugI(ExceptionUtils.getStackTrace(otherException));
			result = false;
		}
		editSession.flushQueue();
		return result;
	}

Merge Catch [catch(DataException e), catch(IOException e)] to catch(DataException|IOException e) in method public restoreRegionBlocks(file File, regionInterface GeneralRegionInterface) : boolean from class me.wiefferink.areashop.handlers.WorldEditHandler5


	@Override
	public boolean saveRegionBlocks(File file, GeneralRegionInterface regionInterface) {
		boolean result = true;
		ProtectedRegion region = regionInterface.getRegion();
		// Get the origin and size of the region
		Vector origin = new Vector(region.getMinimumPoint().getBlockX(), region.getMinimumPoint().getBlockY(), region.getMinimumPoint().getBlockZ());
		Vector size = (new Vector(region.getMaximumPoint().getBlockX(), region.getMaximumPoint().getBlockY(), region.getMaximumPoint().getBlockZ()).subtract(origin)).add(new Vector(1,1,1));
		EditSession editSession = new EditSession(new BukkitWorld(regionInterface.getWorld()), pluginInterface.getConfig().getInt("maximumBlocks"));
		// Save the schematic
		editSession.enableQueue();
		CuboidClipboard clipboard = new CuboidClipboard(size, origin);
		clipboard.copy(editSession);
		Exception otherException = null;
		try {
			SchematicFormat.MCEDIT.save(clipboard, file);
		} catch(DataException|IOException e) {
			otherException = e;
		}
		if(otherException != null) {
			pluginInterface.getLogger().warning("Failed to save schematic for region " + regionInterface.getName());
			pluginInterface.debugI(ExceptionUtils.getStackTrace(otherException));
			result = false;
		}
		editSession.flushQueue();
		return result;
	}

	@Override
	public boolean saveRegionBlocks(File file, GeneralRegionInterface regionInterface) {
		boolean result = true;
		ProtectedRegion region = regionInterface.getRegion();
		// Get the origin and size of the region
		Vector origin = new Vector(region.getMinimumPoint().getBlockX(), region.getMinimumPoint().getBlockY(), region.getMinimumPoint().getBlockZ());
		Vector size = (new Vector(region.getMaximumPoint().getBlockX(), region.getMaximumPoint().getBlockY(), region.getMaximumPoint().getBlockZ()).subtract(origin)).add(new Vector(1,1,1));
		EditSession editSession = new EditSession(new BukkitWorld(regionInterface.getWorld()), pluginInterface.getConfig().getInt("maximumBlocks"));
		// Save the schematic
		editSession.enableQueue();
		CuboidClipboard clipboard = new CuboidClipboard(size, origin);
		clipboard.copy(editSession);
		Exception otherException = null;
		try {
			SchematicFormat.MCEDIT.save(clipboard, file);
		} catch (DataException e) {
			otherException = e;
		} catch (IOException e) {
			otherException = e;
		}
		if(otherException != null) {
			pluginInterface.getLogger().warning("Failed to save schematic for region " + regionInterface.getName());
			pluginInterface.debugI(ExceptionUtils.getStackTrace(otherException));
			result = false;
		}
		editSession.flushQueue();
		return result;
	}

Merge Catch [catch(DataException e), catch(IOException e)] to catch(DataException|IOException e) in method public saveRegionBlocks(file File, regionInterface GeneralRegionInterface) : boolean from class me.wiefferink.areashop.handlers.WorldEditHandler5


	@Override
	public Set<ProtectedRegion> getApplicableRegionsSet(Location location) {
		Set<ProtectedRegion> result = new HashSet<>();
		Vector vector = new Vector(location.getX(), location.getY(), location.getZ());
		for(ProtectedRegion region : pluginInterface.getWorldGuard().getRegionManager(location.getWorld()).getRegions().values()) {
			if(region.contains(vector)) {
				result.add(region);
			}
		}
		return result;
	}

	@Override
	public Set<ProtectedRegion> getApplicableRegionsSet(Location location) {
		Set<ProtectedRegion> result = new HashSet<ProtectedRegion>();
		Vector vector = new Vector(location.getX(), location.getY(), location.getZ());
		for(ProtectedRegion region : pluginInterface.getWorldGuard().getRegionManager(location.getWorld()).getRegions().values()) {
			if(region.contains(vector)) {
				result.add(region);
			}
		}
		return result;
	}

Replace Generic With Diamond HashSet<ProtectedRegion> with HashSet<> in method public getApplicableRegionsSet(location Location) : Set<ProtectedRegion> from class me.wiefferink.areashop.handlers.WorldGuardHandler5


	/**
	 * Checks if the string is a correct time period
	 * @param time String that has to be checked
	 * @return true if format is correct, false if not
	 */
	public boolean checkTimeFormat(String time) {
		/* Check if the string is not empty and check the length */
		if(time == null || time.length() <= 1 || time.indexOf(' ') == -1 || time.indexOf(' ') >= (time.length()-1)) {
			return false;
		}

		/* Check if the suffix is one of these values */
		String suffix = time.substring(time.indexOf(' ')+1, time.length());
		ArrayList<String> identifiers = new ArrayList<>();
		identifiers.addAll(this.getConfig().getStringList("seconds"));
		identifiers.addAll(this.getConfig().getStringList("minutes"));
		identifiers.addAll(this.getConfig().getStringList("hours"));
		identifiers.addAll(this.getConfig().getStringList("days"));
		identifiers.addAll(this.getConfig().getStringList("weeks"));
		identifiers.addAll(this.getConfig().getStringList("months"));
		identifiers.addAll(this.getConfig().getStringList("years"));
		if(!identifiers.contains(suffix)) {
			return false;
		}

		/* check if the part before the space is a number */
		String prefix = time.substring(0, (time.indexOf(' ')));
		return prefix.matches("\\d+");
	}

	/**
	 * Checks if the string is a correct time period
	 * @param time String that has to be checked
	 * @return true if format is correct, false if not
	 */
	public boolean checkTimeFormat(String time) {
		/* Check if the string is not empty and check the length */
		if(time == null || time.length() <= 1 || time.indexOf(' ') == -1 || time.indexOf(' ') >= (time.length()-1)) {
			return false;
		}

		/* Check if the suffix is one of these values */
		String suffix = time.substring(time.indexOf(' ')+1, time.length());
		ArrayList<String> identifiers = new ArrayList<String>();
		identifiers.addAll(this.getConfig().getStringList("seconds"));
		identifiers.addAll(this.getConfig().getStringList("minutes"));
		identifiers.addAll(this.getConfig().getStringList("hours"));
		identifiers.addAll(this.getConfig().getStringList("days"));
		identifiers.addAll(this.getConfig().getStringList("weeks"));
		identifiers.addAll(this.getConfig().getStringList("months"));
		identifiers.addAll(this.getConfig().getStringList("years"));
		if(!identifiers.contains(suffix)) {
			return false;
		}

		/* check if the part before the space is a number */
		String prefix = time.substring(0, (time.indexOf(' ')));
		return prefix.matches("\\d+");
	}

Replace Generic With Diamond ArrayList<String> with ArrayList<> in method public checkTimeFormat(time String) : boolean from class nl.evolutioncoding.areashop.AreaShop


	/**
	 * Get all AreaShop regions intersecting with a WorldEdit selection
	 * @param selection The selection to check
	 * @return A list with all the AreaShop regions intersecting with the selection
	 */
	public static List<GeneralRegion> getASRegionsInSelection(Selection selection) {
		ArrayList<GeneralRegion> result = new ArrayList<>();
		for(ProtectedRegion region : getWERegionsInSelection(selection)) {
			GeneralRegion asRegion = AreaShop.getInstance().getFileManager().getRegion(region.getId());
			if(asRegion != null) {
				result.add(asRegion);
			}
		}
		return result;
	}

	/**
	 * Get all AreaShop regions intersecting with a WorldEdit selection
	 * @param selection The selection to check
	 * @return A list with all the AreaShop regions intersecting with the selection
	 */
	public static List<GeneralRegion> getASRegionsInSelection(Selection selection) {
		ArrayList<GeneralRegion> result = new ArrayList<GeneralRegion>();
		for(ProtectedRegion region : getWERegionsInSelection(selection)) {
			GeneralRegion asRegion = AreaShop.getInstance().getFileManager().getRegion(region.getId());
			if(asRegion != null) {
				result.add(asRegion);
			}
		}
		return result;
	}

Replace Generic With Diamond ArrayList<GeneralRegion> with ArrayList<> in method public getASRegionsInSelection(selection Selection) : List<GeneralRegion> from class nl.evolutioncoding.areashop.Utils