source: tapas/common/implementation/com/ether/EtherHelper.java @ 446

package com.ether;

import org.apache.commons.lang.ArrayUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.springframework.mail.javamail.JavaMailSenderImpl;
import org.springframework.mail.javamail.MimeMessageHelper;

import javax.mail.MessagingException;
import javax.mail.internet.MimeMessage;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.security.DigestException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Random;
import java.util.ResourceBundle;

/**
 * @author vmipsl
 * @date 09 sept. 2011
 */
public abstract class EtherHelper
{
    /**
     * This method returns the list with the firts values of a list of <Pair>
     *
     * @param pairList
     * @return
     */
    @NotNull
    public static <T1, T2> List getFirstValues( @NotNull final List<Pair<T1, T2>> pairList )
    {
        final List firstValues = new ArrayList<T1>( pairList.size() );
        for( final Pair pair : pairList )
            firstValues.add( pair.getFirstValue() );

        return firstValues;
    }

    /**
     * This method returns the list with the second values of a list of <Pair>
     *
     * @param pairList
     * @return
     */
    @NotNull
    public static <T1, T2> List getSecondValues( @NotNull final List<Pair<T1, T2>> pairList )
    {
        final List secondValues = new ArrayList<T2>( pairList.size() );
        for( final Pair pair : pairList )
            secondValues.add( pair.getSecondValue() );

        return secondValues;
    }

    public static double[] convertListDoubleToDoubleArray( @NotNull final List<Double> list )
    {
        Double[] doubleArray = new Double[list.size()];
        doubleArray = list.toArray( doubleArray );
        return ArrayUtils.toPrimitive( doubleArray );
    }

    @NotNull
    public static Integer getRandomBetweenTwoInteger( @NotNull final Integer minValue, @NotNull final Integer maxValue )
    {
        final Random r = new Random();
        return minValue + r.nextInt( maxValue - minValue );
    }

    @NotNull
    public static Double getRandomBetweenTwoDouble( @NotNull final Double minValue, @NotNull final Double maxValue )
    {
        final Random r = new Random();
        final Double value = minValue + r.nextDouble();
        if( value > maxValue )
            return getRandomBetweenTwoDouble( minValue, maxValue );
        else
            return value;
    }

    /**
     * This method writes the text into the file filePath
     *
     * @param filePath
     * @param text
     */
    public static void writeInFile( @NotNull final String filePath, @NotNull final String text )
    {
        try
        {
            final FileWriter fw = new FileWriter( filePath, true );
            final BufferedWriter output = new BufferedWriter( fw );
            output.write( text );
            output.flush();
            output.close();
        }
        catch( IOException ioe )
        {
            ioe.printStackTrace();
        }

    }

    /**
     * This method rounded a value with 'n' number after comma
     *
     * @param value            : the value to convert
     * @param numberOfDecimals : the number of decimals after the comma
     * @return the rounding value
     */
    public static Double floor( final Double value, final int numberOfDecimals )
    {
        final Double powValue = Math.pow( 10.0, numberOfDecimals );
        return Math.floor( ( value * powValue ) + 0.5 ) / powValue;
    }


    /**
     * Returns the specified String as an encrypted hash
     *
     * @param stringToEncrypt
     * @return
     */
    @NotNull
    public static byte[] encryptStringToHash( @NotNull final String stringToEncrypt )
            throws DigestException, NoSuchAlgorithmException
    {
        final byte[] input = stringToEncrypt.getBytes();
        final MessageDigest digest = MessageDigest.getInstance( "SHA-1" );
        digest.update( input, 0, input.length );
        final int hashLength = 20; // SHA-1 donne un hash de longueur 20
        final byte[] hash = new byte[hashLength];
        digest.digest( hash, 0, hashLength );
        return hash;
    }

    /**
     * Returns the specified bytes array hash as a String
     *
     * @param encryptedHash the hash as a bytes array
     * @return the hash as a String
     */
    @NotNull
    public static String displayEncryptedHash( @NotNull final byte[] encryptedHash )
    {
        final StringBuilder stringBuilder = new StringBuilder();
        for( final byte aHash : encryptedHash )
        {
            final int v = aHash & 0xFF;
            if( v < 16 )
                stringBuilder.append( '0' );

            stringBuilder.append( Integer.toString( v, 16 ) );
        }
        return stringBuilder.toString();
    }

    /**
     * This method creates a encrypted password with SHA-1 hash
     *
     * @param password
     * @return
     */
    @NotNull
    public static String encryptPassword( @NotNull final String password )
            throws DigestException, NoSuchAlgorithmException
    {
        final byte[] sHAPassword = EtherHelper.encryptStringToHash( password );
        return EtherHelper.displayEncryptedHash( sHAPassword );
    }


    /**
     * This method executes the script/command given in parameter
     * Example of use : execProcess( "/home_local/pif.sh pof" );
     *
     * @param command
     */
    public static void execProcess( @NotNull final String command )
            throws FormattedException
    {
        try
        {
            final Runtime runtime = Runtime.getRuntime();
            runtime.exec( command );
        }
        catch( IOException e )
        {
            throw new FormattedException( FormattedException.FormattedCode.ERROR_IO_TO_EXECUTE_PROCESS, e );
        }
    }

    /**
     * This method sends a message
     * host (see in properties) : mailhost.ipsl.jussieu.fr
     *
     * @param host
     * @param to
     * @param from
     * @param subject
     * @param text
     * @throws FormattedException
     */
    public static void sendMessage( @NotNull final String host, @NotNull final String from, @NotNull final String to, @NotNull final String subject, @NotNull final String text )
            throws FormattedException
    {
        try
        {
            final JavaMailSenderImpl sender = new JavaMailSenderImpl();
            sender.setHost( host );

            final MimeMessage message = sender.createMimeMessage();
            final MimeMessageHelper helper = new MimeMessageHelper( message );
            helper.setFrom( from );
            helper.setTo( to );
            helper.setSubject( subject );
            helper.setText( text );
            sender.send( message );
        }
        catch( MessagingException e )
        {
            throw new FormattedException( FormattedException.FormattedCode.ERROR_TO_SEND_MESSAGE, e );
        }
    }

    /**
     * This method return the text corresponding to the code in the files messages**.properties
     *
     * @param code
     * @param locale
     * @return
     */
    public static String getMessage( @NotNull final String code, @Nullable final Locale locale )
    {
        ResourceBundle bundle = ResourceBundle.getBundle( "messages", Locale.ENGLISH );
        if( null != locale )
            bundle = ResourceBundle.getBundle( "messages", locale );

        return bundle.getString( code );
    }

}