• Home
• net.yadaframework
• yadaweb
• 0.7.7.R2
• source code
• YadaUtil.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

net.yadaframework.components.YadaUtil Maven / Gradle / Ivy

package net.yadaframework.components;

import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.math.BigInteger;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.text.DateFormat;
import java.text.Normalizer;
import java.text.NumberFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Comparator;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
import java.util.SortedSet;
import java.util.Stack;
import java.util.TimeZone;
import java.util.TreeSet;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

import javax.annotation.Nullable;
import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.imageio.stream.FileImageInputStream;
import javax.imageio.stream.ImageInputStream;

import org.apache.commons.exec.CommandLine;
import org.apache.commons.exec.DefaultExecutor;
import org.apache.commons.exec.ExecuteWatchdog;
import org.apache.commons.exec.PumpStreamHandler;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.SystemUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.ApplicationContext;
import org.springframework.context.MessageSource;
import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.event.EventListener;
import org.springframework.context.i18n.LocaleContextHolder;
import org.springframework.core.type.filter.RegexPatternTypeFilter;
import org.springframework.stereotype.Component;
import org.springframework.util.ReflectionUtils;

import com.drew.imaging.ImageMetadataReader;
import com.drew.metadata.Metadata;
import com.drew.metadata.exif.ExifIFD0Directory;
import com.drew.metadata.exif.ExifSubIFDDirectory;
import com.drew.metadata.gif.GifHeaderDirectory;
import com.drew.metadata.jpeg.JpegDirectory;

import jakarta.persistence.Entity;
import jakarta.validation.constraints.NotNull;
import net.yadaframework.core.CloneableDeep;
import net.yadaframework.core.CloneableFiltered;
import net.yadaframework.core.YadaConfiguration;
import net.yadaframework.exceptions.YadaInternalException;
import net.yadaframework.exceptions.YadaInvalidUsageException;
import net.yadaframework.exceptions.YadaInvalidValueException;
import net.yadaframework.exceptions.YadaSystemException;
import net.yadaframework.persistence.entity.YadaAttachedFile;
import net.yadaframework.raw.YadaIntDimension;
import sogei.utility.UCheckDigit;
import sogei.utility.UCheckNum;

@Component
public class YadaUtil {
	private final static Logger log = LoggerFactory.getLogger(YadaUtil.class);

	@Autowired private YadaConfiguration config;
    @Autowired private AutowireCapableBeanFactory autowireCapableBeanFactory; // For autowiring entities

    static private YadaFileManager yadaFileManager;

    static public ApplicationContext applicationContext; 	// To access the ApplicationContext from anywhere
    static public MessageSource messageSource; 				// To access the MessageSource from anywhere, injected by YadaAppConfig

    public final static long MILLIS_IN_MINUTE = 60*1000;
	public final static long MILLIS_IN_HOUR = 60*MILLIS_IN_MINUTE;
	public final static long MILLIS_IN_DAY = 24*MILLIS_IN_HOUR;

	private SecureRandom secureRandom = new SecureRandom();
	private final static char CHAR_AT = '@';
	private final static char CHAR_DOT = '.';
	private final static char CHAR_SPACE = ' ';

	private static Locale defaultLocale = null;

	private List computedTimezoneOffsets = null;
	private List computedTimezones = null;

	/**
	 * Instance to be used when autowiring is not available
	 */
	public final static YadaUtil INSTANCE = new YadaUtil();

	// @PostConstruct
	@EventListener(ContextRefreshedEvent.class) // Called after the context has been initialized
    public void init() {
		defaultLocale = config.getDefaultLocale();
		yadaFileManager = getBean(YadaFileManager.class);
    }
	
	/**
	 * Returns a list of files from a folder where the name contains the given string, sorted alphabetically
	 * @param folderPath the folder where to looks for files, excluding subfolders.
	 * @param contains a string that the name must contain, can be empty or null to accept any
	 * @return a list of files, can be empty
	 * @throws IOException
	 */
	public List getFilesInFolder(Path folderPath, String contains) throws IOException {
		try (Stream paths = Files.list(folderPath)) {
	        return paths.filter(Files::isRegularFile)
	            .filter(path -> contains == null || path.getFileName().toString().contains(contains))
	            .sorted(Comparator.comparing(Path::getFileName))
	            .collect(Collectors.toList());
		}
	}
	
	/**
	 * Returns a random string (currently an hex random number)
	 * @param minlen minimum length of the string. The maximum length is random.
	 * @return
	 */
	public String getRandomText(int minlen) {
		int random = getRandom(0, Integer.MAX_VALUE);
		return String.format("%0"+minlen+"X", random);
	}

	/**
	 * Joins a number of strings, adding a separator only when the strings are not empty.
	 * In other words, null or empty strings are skipped without adding a separator.
	 * @param separator
	 * @param toJoin
	 * @return
	 */
	public String joinIfNotEmpty(@NotNull String separator, String...toJoin) {
		StringBuilder result = new StringBuilder();
		for (String part : toJoin) {
			if (StringUtils.isNotEmpty(part)) {
				if (result.length()>0) {
					result.append(separator);
				}
				result.append(part);
			}
		}
		return result.toString();
	}

	/**
	 * Given a date in the past, returns a string like "12 minutes ago", "2 hours ago", "today at 12:51", "yesterday at 5:32"...
	 * For dates before yesterday, the full RFC_1123 format is used, as 'Tue, 3 Jun 2008 11:05:30 GMT'.
	 * No "x days ago" format is currently provided.
	 * @param timestamp
	 * @param locale
	 * @param maxHours the max value of x for using the "x hours ago" format after which the "today at hh:mm" format is used
	 * 			The default is 3 when null. There is no maximum value, in order to have a "76 hours ago" result if needed.
	 * @return
	 */
	public String getTimestampAsRelative(ZonedDateTime timestamp, Locale locale, Integer maxHours) {
		maxHours = maxHours==null?3:maxHours;
		final long MILLIS_PER_SECOND = 1000;
		final long MILLIS_PER_MINUTE = MILLIS_PER_SECOND*60;
		final long MILLIS_PER_HOUR = MILLIS_PER_MINUTE*60;
		// final long MILLIS_PER_DAY = MILLIS_PER_HOUR*24;
		long elapsedMillis = System.currentTimeMillis()-timestamp.toInstant().toEpochMilli();
		//
		// Small intervals up to maxHours
		if (elapsedMillis >= 0 && elapsedMillis= 0 && elapsedMillis= 0 && elapsedMillis= 0 && elapsedMillis<(maxHours+1)*MILLIS_PER_HOUR) {
			Long value = elapsedMillis / MILLIS_PER_HOUR;
			return messageSource.getMessage("yada.timestamp.hoursago", new Object[] {value}, locale); // "3 hours ago"
		}
		//
		// Medium intervals from maxHours up to yesterday
		ZonedDateTime zonedNow = ZonedDateTime.now(timestamp.getZone());
		long elapsedDays = daysBetween(timestamp, zonedNow);
		if (elapsedDays>=0 && elapsedDays<2) {
			DateTimeFormatter formatter = DateTimeFormatter.ofPattern("H:m");
			String hm = timestamp.format(formatter);
			if (elapsedDays==0) {
				// Today
				return messageSource.getMessage("yada.timestamp.todayAt", new Object[] {hm}, locale); // "today at 12:43"
			} else if (elapsedDays==1) {
				// Yesterday
				return messageSource.getMessage("yada.timestamp.yesterdayAt", new Object[] {hm}, locale); // "yesterday at 12:43"
			}
		}
		//
		// Long intervals: just show the full date and time
		return timestamp.format(DateTimeFormatter.RFC_1123_DATE_TIME);
	}

	/**
	 * Parse a string as a double, using the correct decimal separator (if any).
	 * @param value a number that may have a decimal part
	 * @param locale
	 * @return a double
	 * @throws ParseException if the string is not a valid double in the locale specified
	 */
	public double stringToDouble(String value, Locale locale) throws ParseException {
		// From https://stackoverflow.com/a/16879667/587641
		NumberFormat numberFormat = NumberFormat.getNumberInstance(locale);
		ParsePosition parsePosition = new ParsePosition(0);
		Number number = numberFormat.parse(value, parsePosition);
		if (parsePosition.getIndex() != value.length()){
			throw new ParseException("Invalid double input: '" + value + "'", parsePosition.getIndex());
		}
		return number.doubleValue();
	}

	/**
	 * Add an element to the list only if the element is not null
	 * @param 
	 * @param list
	 * @param element
	 */
	public  void addIfNotNull(List list, T element) {
		if (element!=null) {
			list.add(element);
		}
	}
	
	/**
	 * Add an element to the list only if not there already
	 * @param 
	 * @param list
	 * @param element
	 */
	public  void addIfMissing(List list, T element) {
		if (!list.contains(element)) {
			list.add(element);
		}
	}

	/**
	 * Create a new TreeSet that sorts values according to the order specified in the parameter.
	 * Values that are missing from sortOrder are sorted alphabetically
	 * @param sortOrder
	 * @return an empty sorted set that can receive a subset of the values in the sortOrder and keep them sorted the same way
	 */
	public Set getEmptySortedSet(List sortOrder) {
    	Map order = new HashMap(); // From value to position
    	for (int j = 0; j < sortOrder.size(); j++) {
    		order.put(sortOrder.get(j), j);
		}
    	Set result = new TreeSet<>(new Comparator() {
			@Override
			public int compare(String left, String right) {
				try {
					return order.get(left).compareTo(order.get(right));
				} catch (Exception e) {
					// In case of error, fallback to alphabetical
					log.error("Can't compare {} with {} (ignored)", left, right);
					if (left!=null) {
						return left.compareTo(right);
					}
					return right!=null?1:0;
				}
			}
    	});
		return result;
	}

	/**
	 * Returns a list of days between two dates included. Days are at midnight in the system timezone.
	 * @param fromInclusive start day, the time is ignored
	 * @param toInclusive end day, the time is ignored
	 */
	public List getDays(Date fromInclusive, Date toInclusive) {
	    LocalDate start = fromInclusive.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
	    LocalDate end = toInclusive.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
	    return getDays(start, end);
	}
	
	/**
	 * Returns a list of days between two dates included.
	 * @param fromInclusive start day, the time is ignored
	 * @param toInclusive end day, the time is ignored
	 */
	public List getDays(LocalDate fromInclusive, LocalDate toInclusive) {
	    List days = new ArrayList<>();
	    LocalDate currentDate = fromInclusive;
	    while (!currentDate.isAfter(toInclusive)) {
	        days.add(currentDate);
	        currentDate = currentDate.plusDays(1);
	    }
	    
	    return days;		
	}

	/**
	 * Given a ISO date, a ISO time and a timezone, return the Date.
	 * @param isoDateString like '2011-12-03'
	 * @param isoTimeString like '10:15' or '10:15:30' (optional, can be null or empty)
	 * @param timezone the timezone where the date/time strings belong (optional, can be null)
	 * @return a Date representing the datetime in the timezone, or null when invalid
	 */
	public Date getDateFromDateTimeIsoString(String isoDateString, String isoTimeString, TimeZone timezone) {
		if (isoDateString==null) {
			return null;
		}
		isoTimeString = StringUtils.trimToNull(isoTimeString);
		String isoDateTimeString = isoDateString + (isoTimeString!=null? ("T" + isoTimeString) : "T00:00");
		try {
			LocalDateTime chosenDateTime = LocalDateTime.parse(isoDateTimeString);
			if (timezone == null) {
				timezone = TimeZone.getDefault();
			}
			ZonedDateTime chosenDateTimeZoned = chosenDateTime.atZone(timezone.toZoneId());
			return Date.from(chosenDateTimeZoned.toInstant());
		} catch (Exception e) {
			log.error("Invalid ISO date/time (returning null)", e);
			return null;
		}
	}

	/**
	 * Returns a string for date and time in the specified timezone and locale
	 * @param date the date to format
	 * @param timezone the timezone in which the date is to be considered
	 * @param locale the locale to use for formatting
	 * @return The RFC-1123 formatted date, such as 'Tue, 3 Jun 2008 11:05:30 GMT'.
	 */
	public String getRfcDateTimeStringForTimezone(Date date, TimeZone timezone, Locale locale) {
		DateTimeFormatter formatter = DateTimeFormatter.RFC_1123_DATE_TIME.withLocale(locale);
		ZoneId zoneId = timezone.toZoneId();
		ZonedDateTime zonedDateTime = ZonedDateTime.ofInstant(date.toInstant(), zoneId);
		return zonedDateTime.format(formatter);
	}

	/**
	 * Convert a date in the timezone to a ISO string, like '2011-12-03'
	 * @param date
	 * @param timezone
	 * @return
	 */
	public String getIsoDateStringForTimezone(Date date, TimeZone timezone) {
		return formatDateTimeForTimezone(date, timezone, DateTimeFormatter.ISO_LOCAL_DATE);
	}

	/**
	 * Convert a time in the timezone to a ISO string, like '10:15' or '10:15:30'
	 * @param date
	 * @param timezone
	 * @return
	 */
	public String getIsoTimeStringForTimezone(Date time, TimeZone timezone) {
		return formatDateTimeForTimezone(time, timezone, DateTimeFormatter.ISO_LOCAL_TIME);
	}

	/**
	 * Convert a datetime in the timezone to a ISO string, like '2011-12-03T10:15:30'
	 * @param date
	 * @param timezone
	 * @return
	 */
	public String getIsoDateTimeStringForTimezone(Date dateTime, TimeZone timezone) {
		return formatDateTimeForTimezone(dateTime, timezone, DateTimeFormatter.ISO_LOCAL_DATE_TIME);
	}

	private String formatDateTimeForTimezone(Date datetime, TimeZone timezone, DateTimeFormatter formatter) {
		if (datetime==null) {
			return "";
		}
		ZoneId zoneId = timezone.toZoneId();
		ZonedDateTime zonedDateTime = ZonedDateTime.ofInstant(datetime.toInstant(), zoneId);
		return zonedDateTime.format(formatter);
	}

	/**
	 * Create a single empty "json" object for use in other methods.
	 * Json objects are actually maps that get converted by Spring on return.
	 * @return
	 */
	public Map makeJsonObject() {
			return new HashMap();
	}

	/**
	 * Given a json stored as a map, returns the json at the specified key.
	 * Non need for this method if the objectPath is a simple key: just use the Map get(key) method.
	 * @param jsonSource
	 * @param objectPath the name of a (nested) json property holding an object
	 * @return the object or null if it does not exist
	 * @see #makeJsonObject(parentObject, path)
	 */
	@SuppressWarnings("unchecked")
	public Map getJsonObject(Map jsonSource, String objectPath) {
		return (Map) getJsonPath(jsonSource, objectPath);
	}

	/**
	 * Given a json stored as a map, returns the json at the specified list index
	 * @param jsonSource
	 * @param listPath the path of the json property holing the list
	 * @param listIndex the list index
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public Map getJsonObject(Map jsonSource, String listPath, int listIndex) {
		return (Map) getJsonArray(jsonSource, listPath).get(listIndex);
	}

	/**
	 * Given a json stored as a map, returns the json array at the specified key
	 * Non need for this method if the objectPath is a simple key: just use the Map get(key) method.
	 * @param jsonSource
	 * @param objectPath
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public List