Added SortOrder Mendix project

Author: 3loader

SortOrder.mpr

@@ -0,0 +1,65 @@
+package communitycommons;
+
+import communitycommons.proxies.DatePartSelector;
+import static communitycommons.proxies.DatePartSelector.day;
+import static communitycommons.proxies.DatePartSelector.month;
+import static communitycommons.proxies.DatePartSelector.year;
+import java.util.Date;
+
+import java.time.LocalDate;
+import java.time.Period;
+import java.time.ZoneId;
+import java.util.Calendar;
+
+public class DateTime {
+
+	/**
+	 * @author mwe
+	 * @author res
+	 * @param firstDate The begin of the period
+	 * @param compareDate The end of the period
+	 * @return The period between the firstDate in the system default timezone, and the compareDate in the system
+	 * default timezone as a Java Period
+	 *
+	 * Code is based on http://stackoverflow.com/questions/1116123/how-do-i-calculate-someones-age-in-java
+	 *
+	 * Adjusted to Java 8 APIs (April, 2019)
+	 */
+	public static Period periodBetween(Date firstDate, Date compareDate) {
+		return Period.between(toLocalDate(firstDate), toLocalDate(compareDate));
+	}
+
+	private static LocalDate toLocalDate(Date someDate) {
+		return someDate.toInstant()
+				.atZone(ZoneId.systemDefault())
+				.toLocalDate();
+	}
+
+	public static long dateTimeToInteger(Date date, DatePartSelector selectorObj) {
+		Calendar newDate = Calendar.getInstance();
+		newDate.setTime(date);
+		int value = -1;
+		switch (selectorObj) {
+			case year:
+				value = newDate.get(Calendar.YEAR);
+				break;
+			case month:
+				value = newDate.get(Calendar.MONTH) + 1;
+				break; // Return starts at 0
+			case day:
+				value = newDate.get(Calendar.DAY_OF_MONTH);
+				break;
+			default:
+				break;
+		}
+		return value;
+	}
+
+	public static long dateTimeToLong(Date date) {
+		return date.getTime();
+	}
+
+	public static Date longToDateTime(Long value) {
+		return new Date(value);
+	}
+}

data-snapshot.zip

@@ -0,0 +1,58 @@
+package communitycommons;
+
+import org.apache.commons.lang3.builder.HashCodeBuilder;
+
+
+public class ImmutablePair<T, U>
+{
+	public static <T, U> ImmutablePair<T, U> of(T left, U right) {
+		return new ImmutablePair<T, U>(left, right);
+	}
+
+	private final T	left;
+	private final U	right;
+
+	private ImmutablePair(T left, U right) {
+		if (left == null)
+			throw new IllegalArgumentException("Left is NULL");
+		if (right == null)
+			throw new IllegalArgumentException("Right is NULL");
+		
+		this.left = left;
+		this.right = right;
+	}
+	
+	public T getLeft() {
+		return left;
+	}
+	
+	public U getRight() {
+		return right;
+	}
+	
+	@Override
+	public String toString() {
+		return "<" + left.toString()+ "," + right.toString() + ">";
+	}
+	
+	@Override
+	public boolean equals(Object other) {
+		if (!(other instanceof ImmutablePair<?,?>))
+			return false;
+		
+		if (this == other)
+			return true;
+		
+		ImmutablePair<?,?> o = (ImmutablePair<?, ?>) other;
+		return left.equals(o.getLeft()) && right.equals(o.getRight());
+	}
+	
+	@Override
+	public int hashCode() {
+		return new HashCodeBuilder(19, 85)
+			.append(left)
+			.append(right)
+			.toHashCode();
+	}
+	
+}

javasource/communitycommons/DateTime.java

@@ -0,0 +1,90 @@
+package communitycommons;
+
+import com.mendix.core.Core;
+import com.mendix.logging.ILogNode;
+import communitycommons.proxies.LogLevel;
+import communitycommons.proxies.LogNodes;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+public class Logging {
+
+	private static Map<String, Long> timers = new HashMap<String, Long>();
+
+	public static void trace(String lognode, String message) {
+		log(lognode, LogLevel.Trace, message, null);
+	}
+
+	public static void info(String lognode, String message) {
+		log(lognode, LogLevel.Info, message, null);
+	}
+
+	public static void debug(String lognode, String message) {
+		log(lognode, LogLevel.Debug, message, null);
+	}
+
+	public static void warn(String lognode, String message, Throwable e) {
+		log(lognode, LogLevel.Warning, message, e);
+	}
+
+	public static void warn(String lognode, String message) {
+		warn(lognode, message, null);
+	}
+
+	public static void error(String lognode, String message, Throwable e) {
+		log(lognode, LogLevel.Error, message, e);
+	}
+
+	public static void error(String lognode, String message) {
+		error(lognode, message, null);
+	}
+
+	public static void critical(String lognode, String message, Throwable e) {
+		log(lognode, LogLevel.Critical, message, e);
+	}
+
+	public static void log(String lognode, LogLevel loglevel, String message, Throwable e) {
+		ILogNode logger = createLogNode(lognode);
+		switch (loglevel) {
+			case Critical:
+				logger.critical(message, e);
+				break;
+			case Warning:
+				logger.warn(message, e);
+				break;
+			case Debug:
+				logger.debug(message);
+				break;
+			case Error:
+				logger.error(message, e);
+				break;
+			case Info:
+				logger.info(message);
+				break;
+			case Trace:
+				logger.trace(message);
+				break;
+		}
+	}
+
+	public static Long measureEnd(String timerName, LogLevel loglevel,
+		String message) {
+		Long cur = new Date().getTime();
+		if (!timers.containsKey(timerName)) {
+			throw new IllegalArgumentException(String.format("Timer with key %s not found", timerName));
+		}
+		Long timeTaken = cur - timers.get(timerName);
+		String time = String.format("%d", timeTaken);
+		log(LogNodes.CommunityCommons.name(), loglevel, "Timer " + timerName + " finished in " + time + " ms. " + message, null);
+		return timeTaken;
+	}
+
+	public static void measureStart(String timerName) {
+		timers.put(timerName, new Date().getTime());
+	}
+
+	public static ILogNode createLogNode(String logNode) {
+		return Core.getLogger(logNode);
+	}
+}