source: ether_megapoli/trunk/service/implementation/com/ether/EtherServiceImpl.java @ 482

package com.ether;

import com.ether.dao.JeuDAO;
import com.ether.dao.McoDAO;
import com.ether.dao.MeasureDAO;
import com.ether.dao.ParameterDAO;
import com.ether.dao.PersonDAO;
import com.ether.dao.PlateformDAO;
import com.ether.dao.UserDAO;
import com.ether.dao.ValueDAO;
import com.ether.mco.Mco;
import com.ether.mco.McoFilter;
import com.ether.user.User;
import com.ether.user.UserFilter;
import com.ether.user.UserState;
import com.medias.annuaire.Personne;
import com.medias.database.objects.Jeu;
import com.medias.database.objects.Parametre;
import com.medias.database.objects.Plateforme;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.springframework.beans.factory.annotation.Required;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * @author vmipsl
 * @date 07 mar 2011
 */
public class EtherServiceImpl
        implements EtherService
{
    @Nullable
    @Transactional(readOnly = true)
    public List<Plateforme> getAllPlateforms()
            throws ServiceException
    {
        try
        {
            return _plateformDAO.getAllPlateforms();
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.PLATEFORM_NOT_FOUND, e );
        }
    }

    @Nullable
    @Transactional(readOnly = true)
    public Plateforme getPlateformById( @Nullable final Integer plateformId )
            throws ServiceException
    {
        if( null == plateformId )
            return null;
        try
        {
            return _plateformDAO.getPlateformById( plateformId );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.PLATEFORM_NOT_FOUND, e );
        }
    }

    @Nullable
    @Transactional(readOnly = true)
    public Parametre getParameterById( @Nullable final Integer parameterId )
            throws ServiceException
    {
        if( null == parameterId )
            return null;
        try
        {
            return _parameterDAO.getParameterById( parameterId );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.PARAMETER_NOT_FOUND, e );
        }
    }

    @NotNull
    @Transactional(readOnly = true)
    public List<Parametre> getParametersByPlateformId( @NotNull final Integer plateformId )
            throws ServiceException
    {
        try
        {
            return _parameterDAO.getParametersByPlateformId( plateformId );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.PARAMETER_NOT_FOUND, e );
        }
    }

    @NotNull
    @Transactional(readOnly = true)
    public <T1, T2, T3> Data<T1[], T2[], T3[]> getListsByPlateformByParameterByPeriodForTimeSerie( @NotNull final Integer plateformId, @NotNull final Integer parameterId, @Nullable final Date dateBegin, @Nullable final Date dateEnd )
            throws ServiceException
    {
        try
        {
            return _valueDAO.getListsByPlateformByParameterByPeriodForTimeSerie( plateformId, parameterId, dateBegin, dateEnd );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.VALUE_NOT_FOUND, e );
        }
    }

    @NotNull
    @Transactional(readOnly = true)
    public <T1, T2, T3> Data<List<T1>, List<T2>, List<T3>> getListsByPlateformByParameterByPeriodFor2D( @NotNull final Integer plateformId, @NotNull final Integer parameterId, @Nullable final Date dateBegin, @Nullable final Date dateEnd )
            throws ServiceException
    {
        try
        {
            return _valueDAO.getListsByPlateformByParameterByPeriodFor2D( plateformId, parameterId, dateBegin, dateEnd );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.VALUE_NOT_FOUND, e );
        }
    }

    @NotNull
    @Transactional(readOnly = true)
    public <T1, T2, T3> Data<T1[], T2[], T3[]> getArraysByPlateformByParameterByPeriodFor2D( @NotNull final Integer plateformId, @NotNull final Integer parameterId, @Nullable final Date dateBegin, @Nullable final Date dateEnd )
            throws ServiceException
    {
        try
        {
            return _valueDAO.getArraysByPlateformByParameterByPeriodFor2D( plateformId, parameterId, dateBegin, dateEnd );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.VALUE_NOT_FOUND, e );
        }
    }

    @NotNull
    @Transactional(readOnly = true)
    public Integer getNumberValuesByPlateformByParameterByPeriod( @NotNull final List<Pair<Integer, Integer>> pairs, @Nullable final Date beginDate, @Nullable final Date endDate )
            throws ServiceException
    {
        try
        {
            Integer number = 0;
            for( final Pair pair : pairs )
                number += _valueDAO.getNumberValuesByPlateformByParameterByPeriod( (Integer) pair.getFirstValue(), (Integer) pair.getSecondValue(), beginDate, endDate );

            return number;
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.VALUE_NOT_FOUND, e );
        }
    }

    @Nullable
    @Transactional(readOnly = true)
    public Date getFirstDate()
            throws ServiceException
    {
        try
        {
            return _measureDAO.getFirstDate();
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.DATE_NOT_FOUND, e );
        }
    }

    @Nullable
    @Transactional(readOnly = true)
    public Date getLastDate()
            throws ServiceException
    {
        try
        {
            return _measureDAO.getLastDate();
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.DATE_NOT_FOUND, e );
        }
    }

    @Nullable
    @Transactional(readOnly = true)
    public User getUserById( @NotNull final Integer userId )
            throws ServiceException
    {
        try
        {
            return _userDAO.selectByPrimaryKey( userId );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.USER_NOT_FOUND, e );
        }
    }

    @Nullable
    @Transactional(readOnly = true)
    public User getUserByEmail( @NotNull final String userEmail )
            throws ServiceException
    {
        try
        {
            return _userDAO.getUserByEmail( userEmail );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.USER_NOT_FOUND, e );
        }
    }

    @NotNull
    @Transactional(rollbackFor = Exception.class)
    public Integer createUser( @NotNull final User user )
            throws ServiceException
    {
        try
        {
            return _userDAO.insert( user );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.PERSISTENCE, e );
        }
    }

    @NotNull
    @Transactional(readOnly = true)
    public List<User> getAllUsers()
            throws ServiceException
    {
        try
        {
            return _userDAO.selectAll();
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.USER_NOT_FOUND, e );
        }
    }

    @NotNull
    @Transactional(readOnly = true)
    public List<User> getAllUsersByNameOrder()
            throws ServiceException
    {
        try
        {
            return _userDAO.getAllUsersByNameOrder();
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.USER_NOT_FOUND, e );
        }
    }

    @NotNull
    @Transactional(readOnly = true)
    public List<User> getUsersByState( @NotNull final UserState userState )
            throws ServiceException
    {
        try
        {
            return _userDAO.getUsersByState( userState );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.USER_NOT_FOUND, e );
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public void removeUserById( @NotNull final Integer userId )
            throws ServiceException
    {
        try
        {
            _userDAO.deleteByPrimaryKey( userId );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.PERSISTENCE, e );
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public void updateUser( @NotNull final User user )
            throws ServiceException
    {
        try
        {
            _userDAO.update( user );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.PERSISTENCE, e );
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public void acceptOrRefuseUser( @NotNull final Integer userId, final boolean isAccepted )
            throws ServiceException
    {
        try
        {
            final User user = _userDAO.selectByPrimaryKey( userId );
            if( isAccepted )
                user.setState( UserState.ACCEPTED );
            else
                user.setState( UserState.REFUSED );
            _userDAO.update( user );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.PERSISTENCE, e );
        }
    }

    @Nullable
    @Transactional(readOnly = true)
    public Personne getPeopleByEmail( @NotNull final String email )
            throws ServiceException
    {
        try
        {
            return _personDAO.getPersonByEmail( email );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.PERSON_NOT_FOUND, e );
        }
    }

    @Transactional(readOnly = true)
    public PaginatedResult<User> searchUsers( @NotNull final UserFilter filter )
            throws ServiceException
    {
        try
        {
            return _userDAO.search( filter );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.USER_NOT_FOUND, e );
        }
    }

    @Transactional(readOnly = true)
    public PaginatedResult<Mco> searchMcos( @NotNull final McoFilter filter )
            throws ServiceException
    {
        try
        {
            return _mcoDAO.search( filter );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.REQUEST_NOT_FOUND, e );
        }
    }

    @Nullable
    @Transactional(readOnly = true)
    public Mco getMcoByCode( @NotNull final String code )
            throws ServiceException
    {
        try
        {
            return _mcoDAO.getMcoByCode( code );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.REQUEST_NOT_FOUND, e );
        }
    }

    @NotNull
    @Transactional(rollbackFor = Exception.class)
    public Integer createMco( @NotNull final Mco mco )
            throws ServiceException
    {
        try
        {
            return _mcoDAO.insert( mco );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.PERSISTENCE, e );
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public void removeMcoById( @NotNull final Integer mcoId )
            throws ServiceException
    {
        try
        {
            _mcoDAO.deleteByPrimaryKey( mcoId );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.PERSISTENCE, e );
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public void updateMco( @NotNull final Mco mco )
            throws ServiceException
    {
        try
        {
            _mcoDAO.update( mco );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.PERSISTENCE, e );
        }
    }

    @Nullable
    @Transactional(readOnly = true)
    public Mco getMcoById( @NotNull final Integer requestId )
            throws ServiceException
    {
        try
        {
            return _mcoDAO.selectByPrimaryKey( requestId );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.REQUEST_NOT_FOUND, e );
        }
    }

    /**
     * This method manage the sub-menus for the list of parameters (to avoid multiple "Particle Concentration" by example)
     * The fullParameters must be ordered with parameterName ascendant
     *
     * @param fullParameters
     * @return
     */
    @NotNull
    public List<List<Parametre>> manageMenusForParameterList( @NotNull final List<Parametre> fullParameters )
    {
        final List<List<Parametre>> parameterListWithMenu = new ArrayList<List<Parametre>>();

        int i = 0;
        while( i < fullParameters.size() )
        {
            final Parametre fullParameter = fullParameters.get( i );
            final int firstIndex = fullParameters.indexOf( fullParameter );
            final int lastIndex = fullParameters.lastIndexOf( fullParameter );
            final List<Parametre> parameters = fullParameters.subList( firstIndex, lastIndex + 1 );
            parameterListWithMenu.add( parameters );
            i += parameters.size();
        }

        return parameterListWithMenu;
    }

    @Nullable
    @Transactional(readOnly = true)
    public List<Parametre> getAllParametersOrderByCategoryByName()
            throws ServiceException
    {
        try
        {
            return _parameterDAO.getAllParametersOrderByCategoryByName();
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.PARAMETER_NOT_FOUND, e );
        }
    }

    @Nullable
    @Transactional(readOnly = true)
    public List<Date> getAllMeasureDateByPlateformId( @NotNull final Integer plateformId )
            throws ServiceException
    {
        try
        {
            return _measureDAO.getAllMeasureDateByPlateformId( plateformId );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.DATE_NOT_FOUND, e );
        }
    }

    @Nullable
    @Transactional(readOnly = true)
    public PaginatedResult<Jeu> searchJeux( @NotNull final JeuFilter filter )
            throws ServiceException
    {
        try
        {
            return _jeuDAO.search( filter );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.JEU_NOT_FOUND, e );
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public void removeJeuById( @NotNull final Integer jeuId )
            throws ServiceException
    {
        // TODO lancer moulinette à VP
        final String bob = "bib";
//        try
//        {
//            _jeuDAO.deleteByPrimaryKey( jeuId );
//        }
//        catch( PersistenceException e )
//        {
//            throw new ServiceException( ServiceException.ServiceCode.PERSISTENCE, e );
//        }
    }

    @Nullable
    @Transactional(readOnly = true)
    public Jeu getJeuById( @NotNull final Integer jeuId )
            throws ServiceException
    {
        try
        {
            return _jeuDAO.selectByPrimaryKey( jeuId );
        }
        catch( PersistenceException e )
        {
            throw new ServiceException( ServiceException.ServiceCode.JEU_NOT_FOUND, e );
        }
    }

    @Required
    public void setPlateformDAO( final PlateformDAO plateformDAO )
    {
        _plateformDAO = plateformDAO;
    }

    @Required
    public void setParameterDAO( final ParameterDAO parameterDAO )
    {
        _parameterDAO = parameterDAO;
    }

    @Required
    public void setValueDAO( final ValueDAO valueDAO )
    {
        _valueDAO = valueDAO;
    }

    @Required
    public void setMeasureDAO( final MeasureDAO measureDAO )
    {
        _measureDAO = measureDAO;
    }

    @Required
    public void setUserDAO( final UserDAO userDAO )
    {
        _userDAO = userDAO;
    }

    @Required
    public void setPersonDAO( final PersonDAO personDAO )
    {
        _personDAO = personDAO;
    }

    @Required
    public void setMcoDAO( final McoDAO mcoDAO )
    {
        _mcoDAO = mcoDAO;
    }

    @Required
    public void setJeuDAO( final JeuDAO jeuDAO )
    {
        _jeuDAO = jeuDAO;
    }

    private static final Log LOGGER = LogFactory.getLog( EtherServiceImpl.class );

    private PlateformDAO _plateformDAO;
    private ParameterDAO _parameterDAO;
    private ValueDAO _valueDAO;
    private MeasureDAO _measureDAO;
    private UserDAO _userDAO;
    private PersonDAO _personDAO;
    private McoDAO _mcoDAO;
    private JeuDAO _jeuDAO;
}