added common objects and exceptions as base for api

src/java/DmWebPortal/src/java/gov/anl/aps/dm/common/objects/DmObject.java

+package gov.anl.aps.dm.common.objects;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import gov.anl.aps.dm.common.exceptions.DmException;
+import java.io.Serializable;
+
+/**
+ * Base DM object class.
+ */
+public class DmObject implements Serializable {
+
+    protected Long id = null;
+    protected String name = null;
+    protected String description = null;
+
+    public DmObject() {
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    /**
+     * Conversion to JSON string representation.
+     *
+     * @return JSON string
+     */
+    public String toJson() {
+        Gson gson = new GsonBuilder().create();
+        return gson.toJson(this);
+    }
+
+    /**
+     * Encode object.
+     *
+     * @throws DmException in case of any errors
+     */
+    public void encode() throws DmException {
+    }
+
+    /**
+     * Decode object.
+     *
+     * @throws DmException in case of any errors
+     */
+    public void decode() throws DmException {
+    }
+}

src/java/DmWebPortal/src/java/gov/anl/aps/dm/common/objects/DmObjectFactory.java

+package gov.anl.aps.dm.common.objects;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.reflect.TypeToken;
+import gov.anl.aps.dm.common.exceptions.DmException;
+import java.lang.reflect.Type;
+import java.util.LinkedList;
+import java.util.List;
+import org.apache.log4j.Logger;
+
+/**
+ * DM object factory class.
+ */
+public class DmObjectFactory {
+
+    private static final Logger logger = Logger.getLogger(DmObjectFactory.class.getName());
+    private static final Gson gson = new GsonBuilder().create();
+
+    /**
+     * Create object from JSON string.
+     *
+     * @param <T> template class
+     * @param jsonString JSON string
+     * @param objectClass object class
+     * @return generated object
+     */
+    public static <T extends Object> T createObject(String jsonString, Class<T> objectClass) {
+        logger.debug("Converting JSON string to object " + objectClass + ": " + jsonString);
+        T object = gson.fromJson(jsonString, objectClass);
+        return object;
+    }
+
+    /**
+     * Create DM object from JSON string.
+     *
+     * @param <T> template class
+     * @param jsonString JSON string
+     * @param dmClass DM object class
+     * @return generated DM object
+     * @throws DmException in case of any errors
+     */
+    public static <T extends DmObject> T createDmObject(String jsonString, Class<T> dmClass) throws DmException {
+        logger.debug("Converting JSON string to DM object " + dmClass + ": " + jsonString);
+        T dmObject = gson.fromJson(jsonString, dmClass);
+        dmObject.decode();
+        return dmObject;
+    }
+
+    /**
+     * Create list of DM objects from JSON string.
+     *
+     * @param <T> template class
+     * @param jsonString DM string
+     * @return generated list of DM objects
+     */
+    public static <T extends DmObject> List<T> createDmObjectList(String jsonString) {
+        // This method does not appear to work as template, so we have
+        // to write specific methods for each object type.
+        logger.debug("Converting JSON string to dm object list: " + jsonString);
+        Type dmType = new TypeToken<LinkedList<T>>() {
+        }.getType();
+        List<T> dmObjectList = gson.fromJson(jsonString, dmType);
+        return dmObjectList;
+    }
+
+    /**
+     * Create list of string objects from JSON string.
+     *
+     * @param jsonString JSON string
+     * @return generated list of string objects
+     */
+    public static List<String> createStringObjectList(String jsonString) {
+        logger.debug("Converting JSON string to string object list: " + jsonString);
+        Type dmType = new TypeToken<LinkedList<String>>() {
+        }.getType();
+        List<String> dmObjectList = gson.fromJson(jsonString, dmType);
+        return dmObjectList;
+    }
+
+}

src/java/DmWebPortal/src/java/gov/anl/aps/dm/common/utilities/ArgumentUtility.java

+package gov.anl.aps.dm.common.utilities;
+
+import gov.anl.aps.dm.common.exceptions.InvalidArgument;
+import gov.anl.aps.dm.common.exceptions.DmException;
+import java.util.Map;
+import javax.xml.bind.DatatypeConverter;
+
+/**
+ * Utility class for processing and checking function arguments.
+ */
+public class ArgumentUtility {
+
+    /**
+     * Check that input string is not null and not empty.
+     *
+     * @param arg input argument to be checked
+     * @return true if input string is not null and not empty, false otherwise
+     */
+    public static boolean isNonEmptyString(String arg) {
+        return arg != null && !arg.isEmpty();
+    }
+
+    /**
+     * Convert input argument to string.
+     *
+     * @param arg input argument to be checked
+     * @return original argument string representation, or empty string if
+     * argument is null
+     */
+    public static String toNonNullString(Object arg) {
+        if (arg == null) {
+            return "";
+        }
+        return arg.toString();
+    }
+
+    /**
+     * Verify that input string is not null and not empty.
+     *
+     * @param argName name of the argument to be verified; used for error
+     * message
+     * @param arg input argument to be checked
+     * @throws InvalidArgument if input string is null or empty
+     */
+    public static void verifyNonEmptyString(String argName, String arg) throws InvalidArgument {
+        if (arg == null || arg.isEmpty()) {
+            throw new InvalidArgument(argName + " must be non-empty string.");
+        }
+    }
+
+    /**
+     * Verify that input string contains given pattern.
+     *
+     * @param argName name of the argument to be verified; used for error
+     * message
+     * @param arg input argument to be checked
+     * @param pattern string that must be contained in the input argument
+     * @throws InvalidArgument if input string is null or empty, or if it does
+     * not contain specified pattern
+     */
+    public static void verifyStringContainsPattern(String argName, String arg, String pattern) throws InvalidArgument {
+        verifyNonEmptyString(argName, arg);
+        verifyNonEmptyString("Pattern", pattern);
+        if (!arg.contains(pattern)) {
+            throw new InvalidArgument(argName + " must contain pattern " + pattern + ".");
+        }
+    }
+
+    /**
+     * Verify that input integer is not null and greater than zero.
+     *
+     * @param argName name of the argument to be verified; used for error
+     * message
+     * @param arg input argument to be checked
+     * @throws InvalidArgument if input number is null or not positive
+     */
+    public static void verifyPositiveInteger(String argName, Integer arg) throws InvalidArgument {
+        if (arg == null || arg <= 0) {
+            throw new InvalidArgument(argName + " must be a positive number.");
+        }
+    }
+
+    /**
+     * Verify that input double is not null and greater than zero.
+     *
+     * @param argName name of the argument to be verified; used for error
+     * message
+     * @param arg input argument to be checked
+     * @throws InvalidArgument if input number is null or not positive
+     */
+    public static void verifyPositiveDouble(String argName, Double arg) throws InvalidArgument {
+        if (arg == null || arg <= 0) {
+            throw new InvalidArgument(argName + " must be a positive number.");
+        }
+    }
+
+    /**
+     * Verify that input object is not null.
+     *
+     * @param argName name of the argument to be verified; used for error
+     * message
+     * @param arg input argument to be checked
+     * @throws InvalidArgument if input string is null or empty
+     */
+    public static void verifyNonNullObject(String argName, Object arg) throws InvalidArgument {
+        if (arg == null) {
+            throw new InvalidArgument(argName + " cannot be null.");
+        }
+    }
+
+    /**
+     * Add (key,value) pair to map if value is not null or empty.
+     *
+     * @param map target map
+     * @param key key
+     * @param value string that will be added to map if it is not null or empty
+     */
+    public static void addNonEmptyKeyValuePair(Map<String, String> map, String key, String value) {
+        if (value != null && !value.isEmpty()) {
+            map.put(key, value);
+        }
+    }
+
+    /**
+     * Add (key,value) pair to map if value is not null or empty.
+     *
+     * @param map target map
+     * @param key key
+     * @param valueObject object that will be added to map if it has non-empty
+     * string representation
+     */
+    public static void addNonEmptyKeyValuePair(Map<String, String> map, String key, Object valueObject) {
+        if (valueObject != null) {
+            String value = valueObject.toString();
+            if (!value.isEmpty()) {
+                map.put(key, value);
+            }
+        }
+    }
+
+    /**
+     * Base 64 encode.
+     *
+     * @param input input string
+     * @return base 64 encoded string
+     * @throws DmException in case of any errors
+     */
+    public static String encode(String input) throws DmException {
+        try {
+            // Input is twice encoded in order to avoid issues like
+            // '+' being interpreted as space
+            if (input == null) {
+                return input;
+            }
+            String s1 = DatatypeConverter.printBase64Binary(input.getBytes());
+            String s2 = DatatypeConverter.printBase64Binary(s1.getBytes());
+            return s2;
+        } catch (Exception ex) {
+            throw new DmException(ex);
+        }
+    }
+
+    /**
+     * Base 64 decode.
+     *
+     * @param input base 64 encoded string
+     * @return decoded string
+     * @throws DmException in case of any errors
+     */
+    public static String decode(String input) throws DmException {
+        try {
+            // Input is twice encoded in order to avoid issues like
+            // '+' being interpreted as space
+            byte[] ba1 = DatatypeConverter.parseBase64Binary(input);
+            byte[] ba2 = DatatypeConverter.parseBase64Binary(new String(ba1));
+            return new String(ba2);
+        } catch (Exception ex) {
+            throw new DmException(ex);
+        }
+    }
+}

src/java/DmWebPortal/src/java/gov/anl/aps/dm/common/utilities/CollectionUtility.java

+package gov.anl.aps.dm.common.utilities;
+
+import java.util.List;
+import java.util.ListIterator;
+import javax.faces.model.SelectItem;
+
+/**
+ * Utility class for manipulating collections.
+ */
+public class CollectionUtility {
+
+    /**
+     * Prepare array of SelectItem objects for menus
+     *
+     * @param entities list of objects
+     * @param selectOne true if resulting array should contain "Select" string
+     * @return array of SelectItem objects
+     */
+    public static SelectItem[] getSelectItems(List<?> entities, boolean selectOne) {
+        int size = selectOne ? entities.size() + 1 : entities.size();
+        SelectItem[] items = new SelectItem[size];
+        int i = 0;
+        if (selectOne) {
+            items[0] = new SelectItem("", "Select");
+            i++;
+        }
+        for (Object x : entities) {
+            items[i++] = new SelectItem(x, x.toString());
+        }
+        return items;
+    }
+
+    /**
+     * Prepare display string for a list of objects.
+     *
+     * @param list object list
+     * @param beginDelimiter beginning delimiter
+     * @param itemDelimiter item delimiter
+     * @param endDelimiter ending delimiter
+     * @return list display string
+     */
+    public static String displayItemList(List<?> list, String beginDelimiter, String itemDelimiter, String endDelimiter) {
+        String result = beginDelimiter;
+        boolean addItemDelimiter = false;
+        if (list != null) {
+            for (Object item : list) {
+                if (!addItemDelimiter) {
+                    addItemDelimiter = true;
+                } else {
+                    result += itemDelimiter;
+                }
+                result += item.toString();
+            }
+        }
+        result += endDelimiter;
+        return result;
+    }
+
+    /**
+     * Prepare display string for a list of objects without outside delimiters.
+     *
+     * @param list object list
+     * @param itemDelimiter item delimiter
+     * @return list display string
+     */
+    public static String displayItemListWithoutOutsideDelimiters(List<?> list, String itemDelimiter) {
+        String beginDelimiter = "";
+        String endDelimiter = "";
+        return displayItemList(list, beginDelimiter, itemDelimiter, endDelimiter);
+    }
+
+    /**
+     * Prepare display string for a list of objects with spaces as delimiters.
+     *
+     * @param list object list
+     * @return list display string
+     */
+    public static String displayItemListWithoutDelimiters(List<?> list) {
+        String beginDelimiter = "";
+        String itemDelimiter = "";
+        String endDelimiter = "";
+        return displayItemList(list, beginDelimiter, itemDelimiter, endDelimiter);
+    }
+
+    /**
+     * Remove null references from list of objects.
+     *
+     * @param list object list
+     */
+    public static void removeNullReferencesFromList(List<?> list) {
+        if (list == null) {
+            return;
+        }
+        ListIterator iterator = list.listIterator();
+        while (iterator.hasNext()) {
+            if (iterator.next() == null) {
+                iterator.remove();
+            }
+        }
+    }
+}

src/java/DmWebPortal/src/java/gov/anl/aps/dm/common/utilities/CryptUtility.java

+package gov.anl.aps.dm.common.utilities;
+
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.security.spec.InvalidKeySpecException;
+import java.util.Random;
+import javax.crypto.SecretKeyFactory;
+import javax.crypto.spec.PBEKeySpec;
+import org.apache.log4j.Logger;
+import org.primefaces.util.Base64;
+
+/**
+ * Utility class for encrypting and verifying passwords.
+ */
+public class CryptUtility {
+
+    private static final String SecretKeyFactoryType = "PBKDF2WithHmacSHA1";
+    private static final int Pbkdf2Iterations = 1003;
+    private static final int Pbkdf2KeyLengthInBits = 192;
+    private static final int SaltLengthInBytes = 4;
+    private static final char[] SaltCharset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".toCharArray();
+    private static final String SaltDelimiter = "$";
+
+    private static final Logger logger = Logger.getLogger(CryptUtility.class.getName());
+
+    /**
+     * Generate random string.
+     *
+     * @param characterSet set to draw characters from
+     * @param length string length
+     * @return generated string
+     */
+    public static String randomString(char[] characterSet, int length) {
+        Random random = new SecureRandom();
+        char[] result = new char[length];
+        for (int i = 0; i < result.length; i++) {
+            // picks a random index out of character set > random character
+            int randomCharIndex = random.nextInt(characterSet.length);
+            result[i] = characterSet[randomCharIndex];
+        }
+        return new String(result);
+    }
+
+    /**
+     * Encrypt password using PBKDF2 key derivation function.
+     *
+     * @param password input password
+     * @return encrypted password
+     */
+    public static String cryptPasswordWithPbkdf2(String password) {
+        String salt = randomString(SaltCharset, SaltLengthInBytes);
+        return saltAndCryptPasswordWithPbkdf2(password, salt);
+    }
+
+    /**
+     * Apply salt string and encrypt password using PBKDF2 standard.
+     *
+     * @param password input password
+     * @param salt salt string
+     * @return encrypted password
+     */
+    public static String saltAndCryptPasswordWithPbkdf2(String password, String salt) {
+        char[] passwordChars = password.toCharArray();
+        byte[] saltBytes = salt.getBytes();
+
+        PBEKeySpec spec = new PBEKeySpec(
+                passwordChars,
+                saltBytes,
+                Pbkdf2Iterations,
+                Pbkdf2KeyLengthInBits
+        );
+        SecretKeyFactory key;
+        try {
+            key = SecretKeyFactory.getInstance(SecretKeyFactoryType);
+            byte[] hashedPassword = key.generateSecret(spec).getEncoded();
+            String encodedPassword = Base64.encodeToString(hashedPassword, true);
+            return salt + SaltDelimiter + encodedPassword;
+        } catch (NoSuchAlgorithmException | InvalidKeySpecException ex) {
+            // Should not happen
+            logger.error("Password cannot be crypted: " + ex);
+        }
+        return null;
+    }
+
+    /**
+     * Verify encrypted password.
+     *
+     * @param password password to be verified
+     * @param cryptedPassword original encrypted password
+     * @return true if passwords match, false otherwise
+     */
+    public static boolean verifyPasswordWithPbkdf2(String password, String cryptedPassword) {
+        int saltEnd = cryptedPassword.indexOf(SaltDelimiter);
+        String salt = cryptedPassword.substring(0, saltEnd);
+        return cryptedPassword.equals(saltAndCryptPasswordWithPbkdf2(password, salt));
+    }
+
+    /*
+     * Main method, used for simple testing.
+     * 
+     * @param args main arguments
+     */
+    public static void main(String[] args) {
+        String password = "dm";
+        System.out.println("Original password: " + password);
+        String cryptedPassword = cryptPasswordWithPbkdf2(password);
+        System.out.println("Crypted password: " + cryptedPassword);
+        System.out.println("Verified: " + verifyPasswordWithPbkdf2(password, cryptedPassword));
+    }
+}

src/java/DmWebPortal/src/java/gov/anl/aps/dm/common/utilities/DateUtility.java

+package gov.anl.aps.dm.common.utilities;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+/**
+ * Utility class for manipulating dates.
+ */
+public class DateUtility {
+
+    private static final SimpleDateFormat DateTimeFormat = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+
+    /**
+     * Format current date.
+     *
+     * @return formatted date string
+     */
+    public static String getCurrentDateTime() {
+        return DateTimeFormat.format(new Date());
+    }
+}

src/java/DmWebPortal/src/java/gov/anl/aps/dm/common/utilities/FileUtility.java

+package gov.anl.aps.dm.common.utilities;
+
+/**
+ * Utility class for manipulating files.
+ */
+public class FileUtility {
+
+    /**
+     * Get file extension.
+     *
+     * @param fileName file name
+     * @return file extension
+     */
+    public static String getFileExtension(String fileName) {
+        String extension = "";
+        if (fileName != null && !fileName.isEmpty()) {
+            int extIndex = fileName.lastIndexOf('.');
+            int dirIndex = Math.max(fileName.lastIndexOf('/'), fileName.lastIndexOf('\\'));
+            if (extIndex > dirIndex) {
+                extension = fileName.substring(extIndex + 1);
+            }
+        }
+        return extension.toLowerCase();
+    }
+
+}

src/java/DmWebPortal/src/java/gov/anl/aps/dm/common/utilities/LdapUtility.java

+package gov.anl.aps.dm.common.utilities;
+
+import gov.anl.aps.dm.portal.utilities.ConfigurationUtility;
+import java.util.Hashtable;
+import javax.naming.Context;
+import javax.naming.NamingException;
+import javax.naming.directory.DirContext;
+import javax.naming.directory.InitialDirContext;
+import org.apache.log4j.Logger;
+
+/**
+ * LDAP utility class for verifying user credentials.
+ *
+ * @see NoServerVerificationSSLSocketFactory
+ */
+public class LdapUtility {
+
+    private static final String LdapUrlPropertyName = "dm.portal.ldapUrl";
+    private static final String LdapDnStringPropertyName = "dm.portal.ldapDnString";
+    private static final String ldapUrl = ConfigurationUtility.getPortalProperty(LdapUrlPropertyName);
+    private static final String ldapDnString = ConfigurationUtility.getPortalProperty(LdapDnStringPropertyName);
+
+    private static final Logger logger = Logger.getLogger(LdapUtility.class.getName());
+
+    /**
+     * Validate user credentials.
+     *
+     * Use username and password to attempt initial connection and bind with
+     * LDAP server. Successful connection implies that credentials are accepted.
+     *
+     * @param username username
+     * @param password password
+     *
+     * @return true if credentials are valid, false otherwise
+     */
+    public static boolean validateCredentials(String username, String password) {
+
+        // dump out immediately if not given password
+        if (password.isEmpty()) {
+            return false;
+        }
+
+        boolean validated = false;
+        Hashtable env = new Hashtable();
+        String dn = ldapDnString.replace("USERNAME", username);
+        logger.debug("Authenticating: " + dn);
+        env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
+        env.put(Context.PROVIDER_URL, ldapUrl);
+        env.put(Context.SECURITY_AUTHENTICATION, "simple");
+        env.put(Context.SECURITY_PRINCIPAL, dn);
+        env.put(Context.SECURITY_CREDENTIALS, password);
+        // the below property allows us to circumvent server certificate checks
+        env.put("java.naming.ldap.factory.socket", "gov.anl.aps.dm.common.utilities.NoServerVerificationSSLSocketFactory");
+        try {
+            DirContext ctx = new InitialDirContext(env);
+            validated = true;
+        } catch (NamingException ex) {
+            logger.error(ex);
+        }
+        return validated;
+    }
+
+}

src/java/DmWebPortal/src/java/gov/anl/aps/dm/common/utilities/NoOpTrustManager.java

+package gov.anl.aps.dm.common.utilities;
+
+import java.security.cert.X509Certificate;
+import javax.net.ssl.X509TrustManager;
+
+/**
+ * Dummy trust manager class.
+ *
+ * A trivial implementation of <code>X509TrustManager</code> that doesn't
+ * actually check the validity of a certificate. This allows us to make SSL
+ * connections to internal servers without requiring the installation and
+ * maintenance of certificates in the client keystore.
+ *
+ * @see NoServerVerificationSSLSocketFactory
+ */
+public class NoOpTrustManager implements X509TrustManager {
+
+    @Override
+    public void checkClientTrusted(X509Certificate[] cert, String authType) {
+    }
+
+    @Override
+    public void checkServerTrusted(X509Certificate[] cert, String authType) {
+    }
+
+    @Override
+    public X509Certificate[] getAcceptedIssuers() {
+        return new X509Certificate[0];
+    }
+}

src/java/DmWebPortal/src/java/gov/anl/aps/dm/common/utilities/NoServerVerificationSSLSocketFactory.java

+package gov.anl.aps.dm.common.utilities;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+import javax.net.SocketFactory;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManager;
+import org.apache.log4j.Logger;
+
+/**
+ * SSL socket factory that does not verify server credentials.
+ *
+ * A minor extension of <code>SSLSocketFactory</code> that installs a dummy
+ * trust manager. This allows creation of SSL sockets that don't verify the
+ * server certificates.
+ *
+ * @see NoOpTrustManager
+ */
+public class NoServerVerificationSSLSocketFactory extends SSLSocketFactory {
+
+    private static final Logger logger = Logger.getLogger(NoServerVerificationSSLSocketFactory.class.getName());
+
+    private SSLSocketFactory factory;
+
+    /**
+     * Default constructor.
+     */
+    public NoServerVerificationSSLSocketFactory() {
+        try {
+            TrustManager tm = new NoOpTrustManager();
+            SSLContext sslcontext = SSLContext.getInstance("TLS");
+            sslcontext.init(null, // No KeyManager required
+                    new TrustManager[]{tm},
+                    new java.security.SecureRandom());
+
+            factory = (SSLSocketFactory) sslcontext.getSocketFactory();
+        } catch (KeyManagementException | NoSuchAlgorithmException ex) {
+            logger.error(ex);
+        }
+    }
+
+    /**
+     * Get default (no server verification) socket factory.
+     *
+     * @return socket factory
+     */
+    public static SocketFactory getDefault() {
+        return new NoServerVerificationSSLSocketFactory();
+    }
+
+    /**
+     * Create SSL socket layered over an existing socket connected to the named
+     * host, at a given port.
+     *
+     * @param socket existing socket
+     * @param host
+     * @param port
+     * @param autoClose
+     * @return created socket
+     * @throws IOException in case of IO errors
+     */
+    @Override
+    public Socket createSocket(Socket socket, String host, int port, boolean autoClose)
+            throws IOException {
+        return factory.createSocket(socket, host, port, autoClose);
+    }
+
+    /**
+     * Create a socket and connect it to the specified remote address/port, and
+     * bind it to the specified local address/port.
+     *
+     * @param address server network address
+     * @param port server port
+     * @param localAddress client network address
+     * @param localPort client port
+     * @return created socket
+     * @throws IOException in case of IO errors
+     */
+    @Override
+    public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort)
+            throws IOException {
+        return factory.createSocket(address, port, localAddress, localPort);
+    }
+
+    /**
+     * Create a socket and connect it to the specified remote address/port.
+     *
+     * @param address server network address
+     * @param port server port
+     * @return created socket
+     * @throws IOException in case of IO errors
+     */
+    @Override
+    public Socket createSocket(InetAddress address, int port) throws IOException {
+        return factory.createSocket(address, port);
+    }
+
+    /**
+     * Create a socket and connect it to the specified remote host/port, and
+     * bind it to the specified local address/port.
+     *
+     * @param host server host
+     * @param port server port
+     * @param localAddress client network address
+     * @param localPort client port
+     * @return created socket
+     * @throws IOException in case of IO errors
+     */
+    @Override
+    public Socket createSocket(String host, int port, InetAddress localAddress, int localPort)
+            throws IOException {
+        return factory.createSocket(host, port, localAddress, localPort);
+    }
+
+    /**
+     * Create a socket and connect it to the specified remote host/port, and
+     * bind it to the specified local address/port.
+     *
+     * @param host server host
+     * @param port server port
+     * @return created socket
+     * @throws IOException in case of IO errors
+     */
+    @Override
+    public Socket createSocket(String host, int port) throws IOException {
+        return factory.createSocket(host, port);
+    }
+
+    /**
+     * Get default cipher suites from socket factory.
+     *
+     * @return list of default ciphers
+     */
+    @Override
+    public String[] getDefaultCipherSuites() {
+        return factory.getSupportedCipherSuites();
+    }
+
+    /**
+     * Get supported cipher suites from socket factory.
+     *
+     * @return list of supported ciphers
+     */
+    @Override
+    public String[] getSupportedCipherSuites() {
+        return factory.getSupportedCipherSuites();
+    }
+
+}

src/java/DmWebPortal/src/java/gov/anl/aps/dm/common/utilities/ObjectUtility.java

+package gov.anl.aps.dm.common.utilities;
+
+/**
+ * Object utility class.
+ */
+public class ObjectUtility {
+
+    /**
+     * Verify that two objects are the same.
+     *
+     * Object references can be null.
+     *
+     * @param <Type> template type of given objects
+     * @param object1 first object
+     * @param object2 second object
+     * @return true if objects are equal, false otherwise
+     */
+    public static <Type> boolean equals(Type object1, Type object2) {
+        if (object1 == null && object2 == null) {
+            return true;
+        }
+        if (object1 == null || object2 == null) {
+            return false;
+        }
+        return object1.equals(object2);
+    }
+}

src/java/DmWebPortal/src/java/gov/anl/aps/dm/common/utilities/StringUtility.java

+package gov.anl.aps.dm.common.utilities;
+
+/**
+ * String utility class.
+ */
+public class StringUtility {
+
+    /**
+     * Verify that two char sequences are the same.
+     *
+     * Input string references can be null.
+     *
+     * @param cs1 first sequence
+     * @param cs2 second sequence
+     * @return true if char sequences are the same, false otherwise
+     */
+    public static boolean equals(CharSequence cs1, CharSequence cs2) {
+        if (cs1 == null && cs2 == null) {
+            return true;
+        }
+        if (cs1 == null || cs2 == null) {
+            return false;
+        }
+        return cs1.equals(cs2);
+    }
+
+    /**
+     * Capitalize first letter of a given string.
+     *
+     * @param input input string
+     * @return capitalized string
+     */
+    public static String capitalize(String input) {
+        return input.substring(0, 1).toUpperCase() + input.substring(1);
+    }
+}