|| ( resourceHistory.getAction( ).getId( ) == nIdActionSolliciterFromContribNiv3 ) )
                            {
                                int nRelance = processRelance( ticket, resourceHistory.getCreationDate( ), dateExecution );
                                nNbTicketRelance = nNbTicketRelance + nRelance;
                                isTicketUpdated = ( nRelance == 1 );
                                break;
                            }
                        }
                    }
                    else
                        if ( nNbRelance < nbRelanceMax )
                        {
                            int nRelance = processRelance( ticket, dateDerniereRelance, dateExecution );
                            nNbTicketRelance = nNbTicketRelance + nRelance;
                            isTicketUpdated = ( nRelance == 1 );
                        }
                        else
                        {
                            int nRelance = processRetour( ticket, dateDerniereRelance, dateExecution );
                            nNbTicketRetour = nNbTicketRetour + nRelance;
                            isTicketUpdated = ( nRelance == 1 );
                        }
                }
            }
            catch( Exception e )
            {
                AppLogService.error( "Erreur du traitement du ticket " + nIdResource, e );

                if ( ( ticket != null ) && ( ticket.getNbRelance( ) != nNbRelance ) )
                {
                    // si le ticket a été mis à jour mais a eu une erreur
                    ticket.setNbRelance( nNbRelance );
                    ticket.setDateDerniereRelance( dateDerniereRelance );
                    TicketHome.update( ticket, false );
                    isTicketUpdated = true;
                }
            }
            finally
            {
                if ( isTicketUpdated )
                {
                    // Index: store the Ticket in the table for the daemon
                    IndexerActionHome.create( TicketIndexerActionUtil.createIndexerActionFromTicket( ticket ) );
                }
            }
        }

        sbLog.append( "Nombre de tickets au statut " )
        .append( _workflowService.getState( nIdStateWaiting, Ticket.TICKET_RESOURCE_TYPE, nIdWorkflow, null ).getName( ) ).append( " dont :" );

    }

    /**
     * Search ditinct id_core from workflow_task_upload_files
     *
     * @param idHistory
     *            the id history
     * @param idCoreUploadFinal
     *            the list of id file to complete
     * @return the list of distinct id_file
     */
    private List<Integer> searchPjFromTaskUploadFiles( int idHistory, List<Integer> idCoreUploadFinal )
    {
        List<Integer> idCoreUploadList = findIsFileFromTaskUploadFiles( idHistory, idCoreUploadFinal );
        if ( !idCoreUploadList.isEmpty( ) )
        {
            idCoreUploadFinal.addAll( idCoreUploadList );
        }
        return idCoreUploadFinal.stream( ).distinct( ).collect( Collectors.toList( ) );
    }

    /**
     * Search list of distinct id_response
     *
     * @param idHistory
     *            the id history
     * @param idResponseTotal
     *            the list of id response to complete
     * @return the list of distinct id_response
     */
    private List<Integer> searchPjFromTaskInfoAndNotifyHistory( int idHistory, List<Integer> idResponseTotal )
    {
        List<Integer> idResponseTaskInfoList = findIdResponseFromTaskInfo( idHistory, idResponseTotal );
        List<Integer> idResponseNotifyHistoryList = findIdResponseFromNotifyHistory( idHistory, idResponseTotal );

        if ( !idResponseTaskInfoList.isEmpty( ) )
        {
            idResponseTotal.addAll( idResponseTaskInfoList );
        }
        if ( !idResponseNotifyHistoryList.isEmpty( ) )
        {
            idResponseTotal.addAll( idResponseNotifyHistoryList );
        }
        return idResponseTotal.stream( ).distinct( ).collect( Collectors.toList( ) );
    }

    /**
     * Manage pj for usager
     *
     * @param ticket
     *            the ticket
     */
    private void managePjforS3ForUsager( Ticket ticket )
    {
        List<Integer> usagerAttachment = TicketTransfertPjService.findUsagerAttachment( ticket );

                            _workflowService.doProcessAction( ticket.getId( ), Ticket.TICKET_RESOURCE_TYPE, nIdActionRetourFromContribNiv3, null, null, null,
                                    true );

                            return 1;
                        }
                        else
                        {
                            AppLogService.error( "Dernière action manuelle non trouvée pour le ticket " + ticket.getId( ) );
                        }
        }
        return 0;
    }

    /**
     * Renvoie la date de prochaine relance
     *
     * @param dateDerniereRelance
     *            date de dernière relance
     * @return date limite de relance
     */
    private Date getDatelimiteRelance( Timestamp dateDerniereRelance )
    {
        Calendar calendarLimiteRelance = Calendar.getInstance( );
        calendarLimiteRelance.setTime( dateDerniereRelance );

        if ( isMinuteMode == 1 )
        {
            calendarLimiteRelance.add( Calendar.MINUTE, nFrequence );
            // date dernière relance + n minutes
        }
        else
        {
            // date à 00h 00mn 00s
            calendarLimiteRelance.set( Calendar.HOUR_OF_DAY, 0 );
            calendarLimiteRelance.set( Calendar.MINUTE, 0 );
            calendarLimiteRelance.set( Calendar.SECOND, 0 );
            calendarLimiteRelance.set( Calendar.MILLISECOND, 0 );
            calendarLimiteRelance.add( Calendar.DAY_OF_YEAR, nFrequence );
            // date dernière relance + n jours
        }
        return calendarLimiteRelance.getTime( );
    }

    /**
     *
     * @param nIdResource
     *            identifiant de la ressource
     * @param nIdWorkflow
     *            identifiant du workflow
     * @return identifiant de la dernière action si dans la liste des actions de sollicitation
     */
    private int getLastManualActionSollicitation( int nIdResource, int nIdWorkflow )
    {
        List<ResourceHistory> listAllHistoryByResource = _resourceHistoryService.getAllHistoryByResource( nIdResource, Ticket.TICKET_RESOURCE_TYPE,
                nIdWorkflow );

        if ( ( listAllHistoryByResource != null ) && !listAllHistoryByResource.isEmpty( ) )
        {
            // récupération de la dernière action manuelle de sollicitation
            for ( int i = 0; i < listAllHistoryByResource.size( ); i++ )

    protected static ReferenceList getUnitsList( AdminUser user, List<Integer> levelList )
    {

        List<AssigneeUnit> listUnitByLevel = new ArrayList<>( );

        for ( Integer level : levelList )
        {
            listUnitByLevel
                    .addAll( SupportEntityHome.getSupportEntityListByLevel( level ).stream( ).map( SupportEntity::getUnit ).collect( Collectors.toList( ) ) );
        }
        ReferenceList lstRef = new ReferenceList( listUnitByLevel.size( ) );
        ReferenceItem emptyReferenceItem = new ReferenceItem( );
        emptyReferenceItem.setCode( StringUtils.EMPTY );
        emptyReferenceItem.setName( I18nService.getLocalizedString( MESSAGE_DEFAULT_LABEL_ENTITY_TASK_FORM, Locale.FRANCE ) );
        emptyReferenceItem.setChecked( true );
        lstRef.add( emptyReferenceItem );

        for ( AssigneeUnit unit : listUnitByLevel )
        {

            if ( RBACService.isAuthorized( unit, AssigneeUnit.PERMISSION_ASSIGN, (User) user ) )
            {
                lstRef.addItem( unit.getUnitId( ), unit.getName( ) );
            }
        }

        return lstRef;
    }

    public void store( TaskNotifyWaitingTicketConfig config )
    {
        try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_UPDATE, WorkflowTicketingPlugin.getPlugin( ) ) )
        {
            int nIndex = 1;

            daoUtil.setInt( nIndex++, config.getMessageDirectionExternalUser( ).ordinal( ) );

            if ( config.getIdFollowingAction( ) == null )
            {
                daoUtil.setIntNull( nIndex++ );
            }
            else
            {
                daoUtil.setInt( nIndex++, config.getIdFollowingAction( ) );
            }

            if ( config.getIdContactAttribute( ) == null )
            {
                daoUtil.setIntNull( nIndex++ );
            }
            else
            {
                daoUtil.setInt( nIndex++, config.getIdContactAttribute( ) );
            }

            if ( config.getDefaultSubject( ) == null )
            {
                daoUtil.setString( nIndex++, StringUtils.EMPTY );
            }
            else
            {
                daoUtil.setString( nIndex++, config.getDefaultSubject( ) );
            }
            daoUtil.setInt( nIndex, config.getIdTask( ) );

        try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_FIRST_MESSAGE, WorkflowTicketingPlugin.getPlugin( ) ) )
        {
            daoUtil.setInt( 1, nIdTicket );

            daoUtil.executeQuery( );

            int nIndex = 1;

            if ( daoUtil.next( ) )
            {
                emailExternalUserMessage = new TicketEmailExternalUserMessage( );
                emailExternalUserMessage.setIdMessageExternalUser( daoUtil.getInt( nIndex++ ) );
                emailExternalUserMessage.setIdTicket( daoUtil.getInt( nIndex++ ) );
                emailExternalUserMessage.setEmailRecipients( daoUtil.getString( nIndex++ ) );
                emailExternalUserMessage.setEmailRecipientsCc( daoUtil.getString( nIndex++ ) );
                emailExternalUserMessage.setMessageQuestion( daoUtil.getString( nIndex++ ) );
                emailExternalUserMessage.setMessageResponse( daoUtil.getString( nIndex++ ) );
                emailExternalUserMessage.setIsAnswered( daoUtil.getBoolean( nIndex++ ) );
                emailExternalUserMessage.setEmailSubject( daoUtil.getString( nIndex++ ) );
            }
        }
        return emailExternalUserMessage;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public TicketEmailExternalUserMessage loadLastByIdTicket( int nIdTicket )

    }

    /**
     * Relance avec contrôle de la date de dernière relance
     *
     * @param ticket
     *            ticket
     * @param dateDerniereRelance
     *            date de dernière relance
     * @param dateExecution
     *            date d'exécution
     * @return nombre de tickets relancé (0 ou 1)
     */
    private int processRelance( Ticket ticket, Timestamp dateDerniereRelance, Date dateExecution )
    {
        Date dateLimiteRelance = getDatelimiteRelance( dateDerniereRelance );

        if ( dateLimiteRelance.before( dateExecution ) )
        {
            ticket.setDateDerniereRelance( new Timestamp( dateExecution.getTime( ) ) );
            ticket.setNbRelance( ticket.getNbRelance( ) + 1 );

            // mise à jour du ticket (sans màj de la date d'update)
            // update date true si retour de sollicitation, false si relance auto
            TicketHome.update( ticket, false );

            // Relance automatique
            _workflowService.doProcessAction( ticket.getId( ), Ticket.TICKET_RESOURCE_TYPE, nIdActionRelance, null, null, null, true );

            return 1;
        }

        return 0;
    }

    /**
     * Gère le retour en fonction de la dernière action manuelle
     *
     * @param ticket
     *            ticket
     * @param dateExecution
     *            date d'exécution
     * @return nombre de tickets en retour (0 ou 1)
     */
    private int processRetour( Ticket ticket, Timestamp dateDerniereRelance, Date dateExecution )
    {
        Date dateLimiteRelance = getDatelimiteRelance( dateDerniereRelance );

        if ( dateLimiteRelance.before( dateExecution ) )
        {
            // retour sollicitation
            int nIdDerniereActionManuelle = getLastManualActionSollicitation( ticket.getId( ), nIdWorkflow );

            if ( nIdDerniereActionManuelle == nIdActionSolliciterFromTerrainNiv2 )

    public void insert( TaskNotifyWaitingTicketConfig config )
    {
        try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_INSERT, WorkflowTicketingPlugin.getPlugin( ) ) )
        {
            int nIndex = 1;

            daoUtil.setInt( nIndex++, config.getIdTask( ) );
            daoUtil.setInt( nIndex++, config.getMessageDirectionExternalUser( ).ordinal( ) );

            if ( config.getIdFollowingAction( ) == null )
            {
                daoUtil.setIntNull( nIndex++ );
            }
            else
            {
                daoUtil.setInt( nIndex++, config.getIdFollowingAction( ) );
            }

            if ( config.getIdContactAttribute( ) == null )
            {
                daoUtil.setIntNull( nIndex++ );
            }
            else
            {
                daoUtil.setInt( nIndex++, config.getIdContactAttribute( ) );
            }

            if ( config.getDefaultSubject( ) == null )
            {
                daoUtil.setString( nIndex, StringUtils.EMPTY );

            sbLog.append( "Aucun ticket au statut en attente d'une réponse" );
            return sbLog.toString( );
        }

        // boucle sur les tickets
        for ( int nIdResource : listResourceWaitingId )
        {
            int nNbRelance = 0;
            Timestamp dateDerniereRelance = null;
            Ticket ticket = null;
            boolean isTicketUpdated = false;
            try
            {
                ticket = TicketHome.findByPrimaryKey( nIdResource );

                if ( ticket != null )
                {
                    nNbRelance = ticket.getNbRelance( );
                    dateDerniereRelance = ticket.getDateDerniereRelance( );

                    if ( ( dateDerniereRelance == null ) || ( nNbRelance == 0 ) )
                    {
                        List<ResourceHistory> allHistory = _resourceHistoryService.getAllHistoryByResource( ticket.getId( ), Ticket.TICKET_RESOURCE_TYPE,
                                nIdWorkflow );
                        allHistory.sort( Comparator.comparing( ResourceHistory::getCreationDate ).reversed( ) ); // tri du plus récent au plus ancien
                        for ( ResourceHistory resourceHistory : allHistory )
                        {
                            // pas de dernière relance, récupération de la date de dernière sollicitation
                            if ( ( resourceHistory.getAction( ).getId( ) == nIdActionSolliciterFromTerrainNiv2 )

                AdminUser user = AdminUserHome.findUserByLogin( AdminUserHome.findUserByEmail( emailRecipient ) );

                TicketEmailExternalUserRecipient infosEmailExternalUser = new TicketEmailExternalUserRecipient( );
                infosEmailExternalUser.setIdResourceHistory( nIdResourceHistory );
                infosEmailExternalUser.setIdTask( getId( ) );
                infosEmailExternalUser.setEmail( user.getEmail( ) );

                List<ExternalUser> listUsers = _externalUserDAO.findExternalUser( user.getLastName( ), user.getEmail( ),
                        String.valueOf( config.getIdContactAttribute( ) ), null, null );

                if ( ( listUsers != null ) && !listUsers.isEmpty( ) )
                {
                    infosEmailExternalUser.setField( listUsers.iterator( ).next( ).getAdditionalAttribute( ) );
                }

                infosEmailExternalUser.setName( user.getLastName( ) );
                infosEmailExternalUser.setFirstName( user.getFirstName( ) );
                _ticketEmailExternalUserRecipientDAO.insert( infosEmailExternalUser );
            }
        }

        String [ ] emailRecipientsCc;

            daoUtil.setInt( nIndex++, config.getMessageDirectionExternalUser( ).ordinal( ) );

            if ( config.getIdFollowingAction( ) == null )
            {
                daoUtil.setIntNull( nIndex++ );
            }
            else
            {
                daoUtil.setInt( nIndex++, config.getIdFollowingAction( ) );
            }

            if ( config.getIdContactAttribute( ) == null )
            {
                daoUtil.setIntNull( nIndex++ );
            }
            else
            {
                daoUtil.setInt( nIndex++, config.getIdContactAttribute( ) );
            }

            if ( config.getDefaultSubject( ) == null )
            {
                daoUtil.setString( nIndex++, StringUtils.EMPTY );
            }
            else
            {
                daoUtil.setString( nIndex++, config.getDefaultSubject( ) );
            }
            daoUtil.setInt( nIndex, config.getIdTask( ) );

        String strEmailRecipients = firstEmailsAgentDemand.getEmailRecipients( );
        String strEmailRecipientsCc = firstEmailsAgentDemand.getEmailRecipientsCc( );
        String strSubject = firstEmailsAgentDemand.getEmailSubject( );

        // Create message item
        TicketEmailExternalUserMessage emailExternalUser = new TicketEmailExternalUserMessage( );
        emailExternalUser.setIdTicket( ticket.getId( ) );
        emailExternalUser.setMessageQuestion( strAgentMessage );
        emailExternalUser.setEmailRecipients( strEmailRecipients );
        emailExternalUser.setEmailRecipientsCc( strEmailRecipientsCc );
        emailExternalUser.setEmailSubject( strSubject );
        _ticketEmailExternalUserDemandDAO.createQuestion( emailExternalUser );

        // Create resource item
        TicketEmailExternalUserHistory emailExternalUserHistory = new TicketEmailExternalUserHistory( );
        emailExternalUserHistory.setIdResourceHistory( nIdResourceHistory );
        emailExternalUserHistory.setIdTask( getId( ) );
        emailExternalUserHistory.setIdMessageExternalUser( emailExternalUser.getIdMessageExternalUser( ) );
        _ticketEmailExternalUserHistoryDAO.insert( emailExternalUserHistory );
    }

    /**
     * Process external user to agent task (response)
     *
     * @param nIdResourceHistory
     *            resourceHistory ID
     * @param ticket
     *            the current ticket
     * @param request
     *            HttpRequest from doAction
     */
    private void processExternalUserTask( int nIdResourceHistory, Ticket ticket, HttpServletRequest request )

public class TaskNotifyWaitingTicketConfig extends TaskConfig
{
    @NotNull
    private MessageDirectionExternalUser _messageDirectionExternalUser;

    private Integer _nIdFollowingAction;

    private Integer _nIdContactAttribute;

    private String _strDefaultSubject;

    /**
     * Gives the message direction
     *
     * @return the message direction
     */
    public MessageDirectionExternalUser getMessageDirectionExternalUser( )
    {
        return _messageDirectionExternalUser;
    }

    /**
     * Sets the message direction
     *
     * @param messageDirectionExternalUser
     *            the message direction to set
     */
    public void setMessageDirectionExternalUser( MessageDirectionExternalUser messageDirectionExternalUser )
    {
        _messageDirectionExternalUser = messageDirectionExternalUser;
    }

    /**
     * @return the idFollowingAction
     */
    public Integer getIdFollowingAction( )
    {
        return _nIdFollowingAction;
    }

    /**
     * @param nIdFollowingAction
     *            the idFollowingAction to set
     */
    public void setIdFollowingAction( Integer nIdFollowingAction )
    {
        _nIdFollowingAction = nIdFollowingAction;
    }

    /**
     * @return true if the direction is agent to external user
     */
    public boolean isMessageToExternalUser( )
    {
        return MessageDirectionExternalUser.AGENT_TO_EXTERNAL_USER.equals( _messageDirectionExternalUser );
    }

    /**
     * @return the idContactAttribute
     */
    public Integer getIdContactAttribute( )
    {
        return _nIdContactAttribute;
    }

    /**
     * @param nIdContactAttribute
     *            Id Contact Attribute
     */
    public void setIdContactAttribute( Integer nIdContactAttribute )
    {
        _nIdContactAttribute = nIdContactAttribute;
    }

    public String getDefaultSubject( )
    {
        return _strDefaultSubject;
    }

    public void setDefaultSubject( String defaultSubject )
    {
        _strDefaultSubject = defaultSubject;
    }
}

                    try
                    {
                        TransactionManager.beginTransaction( _plugin );

                        // recuperation des PJ usager
                        managePjforS3ForUsager( ticket );

                        // recuperation des PJ agent par id_history
                        List<Integer> idResponseTotal = new ArrayList<>( );
                        List<Integer> idCoreUploadFinal = new ArrayList<>( );

                        List<Integer> idHistoryList = _daoResourceHist.getIdHistoryListByResource( ticket.getId( ), _plugin );
                        for ( int idHistory : idHistoryList )
                        {
                            // tables workflow_task_ticketing_information et workflow_task_notify_gru_history
                            idResponseTotal = searchPjFromTaskInfoAndNotifyHistory( idHistory, idResponseTotal );

                            // table workflow_task_upload_files
                            idCoreUploadFinal = searchPjFromTaskUploadFiles( idHistory, idCoreUploadFinal );
                        }

                        if ( !idResponseTotal.isEmpty( ) )
                        {
                            managePjforS3WithIdResponse( idResponseTotal, ticket );
                        }
                        if ( !idCoreUploadFinal.isEmpty( ) )
                        {
                            // usager false
                            managePjforS3ForAgent( idCoreUploadFinal, ticket, false );
                        }

            while ( daoUtil.next( ) )
            {
                nIndex = 1;
                emailExternalUserMessage = new TicketEmailExternalUserMessage( );
                emailExternalUserMessage.setIdMessageExternalUser( daoUtil.getInt( nIndex++ ) );
                emailExternalUserMessage.setIdTicket( daoUtil.getInt( nIndex++ ) );
                emailExternalUserMessage.setEmailRecipients( daoUtil.getString( nIndex++ ) );
                emailExternalUserMessage.setEmailRecipientsCc( daoUtil.getString( nIndex++ ) );
                emailExternalUserMessage.setMessageQuestion( daoUtil.getString( nIndex++ ) );
                emailExternalUserMessage.setMessageResponse( daoUtil.getString( nIndex++ ) );
                emailExternalUserMessage.setIsAnswered( daoUtil.getBoolean( nIndex++ ) );
                emailExternalUserMessage.setEmailSubject( daoUtil.getString( nIndex++ ) );

            daoUtil.setInt( nIndex++, config.getMessageDirectionExternalUser( ).ordinal( ) );

            if ( config.getIdFollowingAction( ) == null )
            {
                daoUtil.setIntNull( nIndex++ );
            }
            else
            {
                daoUtil.setInt( nIndex++, config.getIdFollowingAction( ) );
            }

            if ( config.getIdContactAttribute( ) == null )
            {
                daoUtil.setIntNull( nIndex++ );
            }
            else
            {
                daoUtil.setInt( nIndex++, config.getIdContactAttribute( ) );
            }

            if ( config.getDefaultSubject( ) == null )
            {
                daoUtil.setString( nIndex, StringUtils.EMPTY );

                emailExternalUserMessage = new TicketEmailExternalUserMessage( );
                emailExternalUserMessage.setIdMessageExternalUser( daoUtil.getInt( nIndex++ ) );
                emailExternalUserMessage.setIdTicket( daoUtil.getInt( nIndex++ ) );
                emailExternalUserMessage.setEmailRecipients( daoUtil.getString( nIndex++ ) );
                emailExternalUserMessage.setEmailRecipientsCc( daoUtil.getString( nIndex++ ) );
                emailExternalUserMessage.setMessageQuestion( daoUtil.getString( nIndex++ ) );
                emailExternalUserMessage.setMessageResponse( daoUtil.getString( nIndex++ ) );
                emailExternalUserMessage.setIsAnswered( daoUtil.getBoolean( nIndex++ ) );
                emailExternalUserMessage.setEmailSubject( daoUtil.getString( nIndex++ ) );

        ReferenceList lstRef = new ReferenceList( listUnitByLevel.size( ) );
        ReferenceItem emptyReferenceItem = new ReferenceItem( );
        emptyReferenceItem.setCode( StringUtils.EMPTY );
        emptyReferenceItem.setName( I18nService.getLocalizedString( MESSAGE_DEFAULT_LABEL_ENTITY_TASK_FORM, Locale.FRANCE ) );
        emptyReferenceItem.setChecked( true );
        lstRef.add( emptyReferenceItem );

        for ( AssigneeUnit unit : listUnitByLevel )
        {

            if ( RBACService.isAuthorized( unit, AssigneeUnit.PERMISSION_ASSIGN, (User) user ) )
            {
                lstRef.addItem( unit.getUnitId( ), unit.getName( ) );
            }
        }

        return lstRef;
    }

    private int nIdActionRetourFromContribNiv3 = AppPropertiesService.getPropertyInt( "workflow-ticketing.actions.id.return.sollicite.contrib_un",
            TicketingConstants.PROPERTY_UNSET_INT );

    // nombre de relances maximum avant retour de la sollicitation
    private int nbRelanceMax = PluginConfigurationService.getInt( PluginConfigurationService.PROPERTY_RELANCE_NB_MAX, 3 );
    // durée en jours entre chaque relance
    private int nFrequence = PluginConfigurationService.getInt( PluginConfigurationService.PROPERTY_RELANCE_FREQUENCE, 10 );

    @Override
    public void run( )
    {
        setLastRunLogs( processNotification( ) );
    }

    private String processNotification( )
    {
        StringBuilder sbLog = new StringBuilder( );

        boolean isParamOK = isConfParamOK( sbLog );
        if ( !isParamOK )
        {
            return sbLog.toString( );
        }

        // Date execution
        Date dateExecution = new Date( );

        int nNbTicketRelance = 0;
        int nNbTicketRetour = 0;

        // step 0: récupération des ressources au statut "En attente d'une reponse"

        List<Integer> listResourceWaitingId = _workflowService.getResourceIdListByIdState( nIdStateWaiting, Ticket.TICKET_RESOURCE_TYPE );