com.github.gkutiel.flip.utils.Utils Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of flip-utils Show documentation
utillities library for flip-web and flip-db
The newest version!
package com.github.gkutiel.flip.utils;

import java.io.ByteArrayInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.*;
import java.util.Map.Entry;

import javax.xml.bind.annotation.adapters.HexBinaryAdapter;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.apache.commons.io.IOUtils;
import org.w3c.dom.Document;
import org.xml.sax.SAXException;

public enum Utils {
	;
	public static enum Collections {
		;
		public interface Filter {
			boolean accept(T t);
		}

		public interface Transformer {
			T2 transform(T1 t1);
		}

		public static  List filter(final Collection collection, final Filter filter) {
			final List newList = new ArrayList<>();

			for (final T t : collection)
				if (filter.accept(t)) newList.add(t);

			return newList;
		}

		@SafeVarargs
		public static  T[] push(final T[] array, final T... vals) {
			final T[] newArray = Arrays.copyOf(array, array.length + vals.length);
			for (int i = 0; i < vals.length; i++)
				newArray[array.length + i] = vals[i];
			return newArray;
		}

		public static  Set toSet(final Iterable it) {
			final Set set = new HashSet<>();
			for (final T t : it)
				set.add(t);
			return set;
		}

		public static  List transform(final Collection collection, final Transformer transformer) {
			final List newList = new ArrayList<>();

			for (final T1 t1 : collection)
				newList.add(transformer.transform(t1));

			return newList;
		}

		public static  Map transformValues(final Map map, final Transformer transformer) {
			final Map newMap = new HashMap<>();

			for (final Entry e : map.entrySet())
				newMap.put(e.getKey(), transformer.transform(e.getValue()));

			return newMap;
		}
	}

	public static enum Cryptography {
		;
		private static final KeyPair KEY_PAIR;
		private static final HexBinaryAdapter ADAPTER = new HexBinaryAdapter();
		private static final String SIG_ALG = "SHA1withDSA";

		static {
			try {
				final KeyPair tmp = loadKeys();
				if (tmp != null) KEY_PAIR = tmp;
				else {
					KEY_PAIR = KeyPairGenerator.getInstance("DSA").generateKeyPair();
					saveKeys(KEY_PAIR);
				}
			} catch (final NoSuchAlgorithmException e) {
				throw new RuntimeException(e);
			}
		}

		public static String md5(final byte[] data) {
			try {
				return ADAPTER.marshal(MessageDigest.getInstance("MD5").digest(data));
			} catch (final NoSuchAlgorithmException e) {
				throw new RuntimeException(e);
			}
		}

		public static String md5(final String data) {
			return md5(data.getBytes());
		}

		public static String sign(final byte[] data) {
			try {
				final Signature sig = Signature.getInstance(SIG_ALG);
				sig.initSign(KEY_PAIR.getPrivate());
				sig.update(data);
				return ADAPTER.marshal(sig.sign());
			} catch (final Exception e) {
				throw new RuntimeException(e);
			}
		}

		public static String sign(final String data) {
			return sign(data.getBytes());
		}

		public static boolean verify(final byte[] data, final String sign) {
			try {
				final Signature sig = Signature.getInstance(SIG_ALG);
				sig.initVerify(KEY_PAIR.getPublic());
				sig.update(data);
				return sig.verify(ADAPTER.unmarshal(sign));
			} catch (final Exception e) {
				return false;
			}
		}

		public static boolean verify(final String data, final String sign) {
			return verify(data.getBytes(), sign);
		}

		private static KeyPair loadKeys() {
			try {
				final KeyFactory keyFactory = KeyFactory.getInstance("DSA");
				final PublicKey pub = keyFactory.generatePublic(new X509EncodedKeySpec(IOUtils.toByteArray(new FileInputStream("key.pub"))));
				final PrivateKey pri = keyFactory.generatePrivate(new PKCS8EncodedKeySpec(IOUtils.toByteArray(new FileInputStream("key.pri"))));
				return new KeyPair(pub, pri);
			} catch (final Exception e) {
				return null;
			}
		}

		private static void saveKeys(final KeyPair keyPair) {
			try {
				new FileOutputStream("key.pub").write(new X509EncodedKeySpec(keyPair.getPublic().getEncoded()).getEncoded());
				new FileOutputStream("key.pri").write(new PKCS8EncodedKeySpec(keyPair.getPrivate().getEncoded()).getEncoded());
			} catch (final IOException e) {
				throw new RuntimeException(e);
			}
		}
	}

	public enum Resource {
		;
		public static String load(final String fileName) {
			try {
				return IOUtils.toString(ClassLoader.getSystemClassLoader().getResourceAsStream(fileName));
			} catch (final IOException e) {
				throw new RuntimeException(e);
			}
		}
	}

	public static enum Strings {
		;
		public static String concat(final String delimeter, final String... strings) {
			if (strings == null || strings.length == 0) return EMPTY_STRING;
			final StringBuilder builder = new StringBuilder();
			builder.append(strings[0]);
			for (int i = 1; i < strings.length; i++) {
				builder.append(delimeter);
				builder.append(strings[i]);
			}
			return builder.toString();
		}

		public static String emptyIfNull(final String str) {
			return str == null ? EMPTY_STRING : str;
		}

		public static boolean emptyOrNull(final String str) {
			return str == null || str.length() == 0;
		}
	}

	public static enum Url {
		;
		public static String urlEncode(final Map args) {
			try {
				if (args == null || args.size() == 0) return EMPTY_STRING;
				final StringBuilder builder = new StringBuilder();
				final Iterator it = args.entrySet().iterator();
				@SuppressWarnings("unchecked")
				final Entry arg = (Entry) it.next();
				builder.append(URLEncoder.encode(arg.getKey(), UTF_8));
				builder.append("=");
				builder.append(URLEncoder.encode(arg.getValue().toString(), UTF_8));
				while (it.hasNext()) {
					builder.append("&");
					builder.append(URLEncoder.encode(arg.getKey(), UTF_8));
					builder.append("=");
					builder.append(URLEncoder.encode(arg.getValue().toString(), UTF_8));
				}
				return builder.toString();
			} catch (final UnsupportedEncodingException e) {
				throw new RuntimeException(e);
			}
		}

	}

	public static enum Xml {
		;

		private static final DocumentBuilder DOCUMENT_BUILDER;
		static {
			try {
				DOCUMENT_BUILDER = DocumentBuilderFactory.newInstance().newDocumentBuilder();
			} catch (final ParserConfigurationException e) {
				throw new RuntimeException(e);
			}
		}

		public static Document document(final String xml) {
			try {
				return DOCUMENT_BUILDER.parse(new ByteArrayInputStream(xml.getBytes()));
			} catch (SAXException | IOException e) {
				throw new RuntimeException(e);
			}
		}

		public static String toString(final Document doc) throws TransformerConfigurationException, TransformerException, TransformerFactoryConfigurationError {
			final StringWriter stringWriter = new StringWriter();
			TransformerFactory.newInstance().newTransformer().transform(new DOMSource(doc), new StreamResult(stringWriter));
			return stringWriter.toString();
		}
	}

	private static final String EMPTY_STRING = "";

	private static final String UTF_8 = "UTF-8";

	public static void main(final String[] args) {
		final String[] lala = new String[] { "gaga", "baa" };
		final String[] push = Collections.push(lala, "dada", "baada");
		System.out.println(Arrays.toString(push));
	}
}