source: ether_megapoli/trunk/common/implementation/com/ether/EtherHelper.java @ 279

package com.ether;

import org.apache.commons.lang.ArrayUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

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.Random;

/**
 * @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;
    }

    // TODO : supprimer cette méthode et utiliser JSON pour récupérer pIdPIdList
    @Nullable
    public static <T1 extends Object, T2 extends Object> List<Pair<T1, T2>> extractpfIdPIdListFromString( @NotNull final String pfIdPIdArrayString, @NotNull final Class<T1> T1Class, @NotNull final Class<T2> T2Class )
    {
        if( pfIdPIdArrayString.isEmpty() )
            return null;

        final String[] pfIDPIdArray = pfIdPIdArrayString.split( "," );
        final List<Pair<T1, T2>> pfIdPIdList = new ArrayList<Pair<T1, T2>>( pfIDPIdArray.length );
        for( final String pfIdPId : pfIDPIdArray )
        {
            final String[] pfIdPIdSplit = pfIdPId.split( "-" );
            final Pair<T1, T2> pfIdPIdPair = new Pair<T1, T2>();
            if( T1Class.equals( String.class ) )
                pfIdPIdPair.setFirstValue( (T1) pfIdPIdSplit[0] );
            else
                pfIdPIdPair.setFirstValue( (T1) Integer.valueOf( pfIdPIdSplit[0] ) );

            if( T2Class.equals( String.class ) )
                pfIdPIdPair.setSecondValue( (T2) pfIdPIdSplit[1] );
            else
                pfIdPIdPair.setSecondValue( (T2) Integer.valueOf( pfIdPIdSplit[1] ) );
            pfIdPIdList.add( pfIdPIdPair );
        }
        return pfIdPIdList;
    }

    /**
     * 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 );
    }

}