daoUtil.setString( nIndex++, form.getTitle( ) );
            daoUtil.setString( nIndex++, form.getDescription( ) );
            Timestamp tsUpdateDate = new Timestamp( Calendar.getInstance( ).getTimeInMillis( ) );
            daoUtil.setTimestamp( nIndex++, tsUpdateDate );
            daoUtil.setTimestamp( nIndex++, form.getAvailabilityStartDate( ) );
            daoUtil.setTimestamp( nIndex++, form.getAvailabilityEndDate( ) );
            daoUtil.setString( nIndex++, form.getWorkgroup( ) );
            daoUtil.setInt( nIndex++, form.getIdWorkflow( ) );
            daoUtil.setBoolean( nIndex++, form.isAuthentificationNeeded( ) );
            daoUtil.setBoolean( nIndex++, form.isOneResponseByUser( ) );
            daoUtil.setString( nIndex++, form.getBreadcrumbName( ) );
            daoUtil.setBoolean( nIndex++, form.isDisplaySummary( ) );
            daoUtil.setString( nIndex++, form.getReturnUrl( ) );
            daoUtil.setInt( nIndex++, form.getMaxNumberResponse( ) );
            daoUtil.setBoolean( nIndex++, form.isCaptchaStepInitial( ) );
            daoUtil.setBoolean( nIndex++, form.isCaptchaStepFinal( ) );
            daoUtil.setBoolean( nIndex++, form.isCaptchaRecap( ) );
            daoUtil.setBoolean( nIndex++, form.isCountResponses( ) );
            daoUtil.setString( nIndex++, form.getLabelFinalButton( ) );
            daoUtil.setString( nIndex++, form.getUnavailableMessage( ) );
            if ( form.getLogo( ) != null )
            {
                daoUtil.setInt( nIndex++, form.getLogo( ).getIdFile( ) );
            }
            else
            {
                daoUtil.setInt( nIndex++, 0 );
            }
            daoUtil.setInt( nIndex++, form.getIdCategory( ) );
            daoUtil.setBoolean( nIndex++, form.isBackupEnabled( ) );
            daoUtil.setBoolean( nIndex++, form.isAccessToResponsesByRole( ) );

            daoUtil.executeUpdate( );

                return cell;
            }
        }
        return null;
    }
    
    /**
     * Gets the response value.
     *
     * @param formQuestionResponse
     *            the form question response
     * @param iteration
     *            the iteration
     * @return the response value
     */
    private List<String> getResponseValue( FormQuestionResponse formQuestionResponse, int iteration )
    {
        Entry entry = formQuestionResponse.getQuestion( ).getEntry( );

        IEntryTypeService entryTypeService = EntryTypeServiceManager.getEntryTypeService( entry );
        List<String> listResponseValue = new ArrayList<>( );
        if ( entryTypeService instanceof AbstractEntryTypeComment )
        {
            return listResponseValue;
        }

        if ( entryTypeService instanceof EntryTypeTermsOfService )
        {
            boolean aggrement = formQuestionResponse.getEntryResponse( ).stream( )
                    .filter( response -> response.getField( ).getCode( ).equals( EntryTypeTermsOfService.FIELD_AGREEMENT_CODE ) )
                    .map( Response::getResponseValue ).map( Boolean::valueOf ).findFirst( ).orElse( false );

            if ( aggrement )
            {
                listResponseValue.add( I18nService.getLocalizedString( KEY_LABEL_YES, I18nService.getDefaultLocale( ) ) );
            }
            else
            {
                listResponseValue.add( I18nService.getLocalizedString( KEY_LABEL_NO, I18nService.getDefaultLocale( ) ) );
            }
            return listResponseValue;

        }
        for ( Response response : formQuestionResponse.getEntryResponse( ) )
        {
            if ( response.getIterationNumber( ) != -1 && response.getIterationNumber( ) != iteration )
            {
                continue;
            }

    public EntryTypeDefaultDisplayService( String strEntryServiceName )
    {
        _strEntryServiceName = strEntryServiceName;
    }

    /**
     * Return the completed model
     * 
     * @param entry
     *            The given entry
     * @param model
     *            The given model
     * @return the completed model
     */
    private Map<String, Object> setModel( Entry entry, Map<String, Object> model )
    {
        model.put( FormsConstants.QUESTION_ENTRY_MARKER, entry );

        return model;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getDisplayServiceName( )
    {
        return _strEntryServiceName;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getEntryTemplateDisplay( HttpServletRequest request, Entry entry, Locale locale, Map<String, Object> model, DisplayType displayType )
    {
        String strEntryHtml = StringUtils.EMPTY;
        IEntryTypeService service = EntryTypeServiceManager.getEntryTypeService( entry );

        switch( displayType.getMode( ) )
        {
            case EDITION:
                strEntryHtml = AppTemplateService.getTemplate( service.getTemplateHtmlForm( entry, displayType.isFront( ) ), locale, setModel( entry, model ) )
                        .getHtml( );
                break;
            case READONLY:
                model.put( MARK_ENTRY_TYPE_SERVICE, service );
                strEntryHtml = AppTemplateService.getTemplate( service.getTemplateEntryReadOnly( displayType.isFront( ) ), locale, setModel( entry, model ) )
                        .getHtml( );
                break;
            default: // Nothing to do
        }

        return strEntryHtml;
    }

    /**
     * Get the form column
     * 
     * @param nFormColumnPosition
     * @param strColumnTitle
     * @param listEntryTitle
     * @return The form column
     */
    @Override
    public IFormColumn getFormColumn( int nFormColumnPosition, String strColumnTitle )
    {
        return new FormColumnEntry( nFormColumnPosition, strColumnTitle );

    }

    /**
     * @return the formDisplayList
     */
    public List<FormDisplay> getFormDisplayList( )
    {
        return new ArrayList<>( _formDisplayList );
    }

    /**
     * @param formDisplayList
     *            the formDisplayList to set
     */
    public void setFormDisplayList( List<FormDisplay> formDisplayList )
    {
        _formDisplayList = new ArrayList<>( formDisplayList );
    }

    /**
     * @return the groupList
     */
    public List<Group> getGroupList( )
    {
        return new ArrayList<>( _groupList );
    }

    /**
     * @param groupList
     *            the groupList to set
     */
    public void setGroupList( List<Group> groupList )
    {
        _groupList = new ArrayList<>( groupList );
    }

    /**
     * @return the controlList
     */
    public List<Control> getControlList( )
    {
        return new ArrayList<>( _controlList );
    }

    /**
     * @param controlList
     *            the controlQuestionList to set
     */
    public void setControlList( List<Control> controlList )
    {
        _controlList = new ArrayList<>( controlList );
    }

    /**
     * @return the controlGroupList
     */
    public List<ControlGroup> getControlGroupList( )
    {
        return new ArrayList<>( _controlGroupList );
    }

    /**
     * @param controlGroupList
     *            the controlGroupList to set
     */
    public void setControlGroupList( List<ControlGroup> controlGroupList )
    {
        _controlGroupList = new ArrayList<>( controlGroupList );
    }

    /**
     * @return the controlMappingList
     */
    public List<ControlMapping> getControlMappingList( )
    {
        return new ArrayList<>( _controlMappingList );
    }

    /**
     * @param controlMappingList
     *            the controlMappingList to set
     */
    public void setControlMappingList( List<ControlMapping> controlMappingList )
    {
        _controlMappingList = new ArrayList<>( controlMappingList );
    }

    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getTemplateEntryReadOnly( boolean bDisplayFront )
    {
        if ( bDisplayFront )
        {
            return TEMPLATE_READONLY_FRONTOFFICE;
        }

        return TEMPLATE_READONLY_BACKOFFICE;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean isResponseChanged( List<Response> listResponseReference, List<Response> listResponseNew )
    {
        if ( listResponseReference.size( ) != listResponseNew.size( ) )
        {
            return true;
        }

        boolean bAllResponsesEquals = true;

        for ( Response responseNew : listResponseNew )
        {
            Response responseReference = findReferenceResponseAssociatedToNewResponse( responseNew, listResponseReference );

            if ( responseReference == null || responseReference.getResponseValue( ) == null
                    || !responseReference.getResponseValue( ).equals( responseNew.getResponseValue( ) ) )
            {
                bAllResponsesEquals = false;
                break;
            }
        }

        return !bAllResponsesEquals;
    }

    /**
     * Finds the reference response associated to the new response
     * 
     * @param responseNew
     *            the new response
     * @param listResponseReference
     *            the list of reference responses
     * @return the found response or {@code null} if not found
     */
    private Response findReferenceResponseAssociatedToNewResponse( Response responseNew, List<Response> listResponseReference )
    {
        Response response = null;

        for ( Response responseReference : listResponseReference )
        {
            if ( responseReference.getField( ).getCode( ).equals( responseNew.getField( ).getCode( ) ) )
            {
                response = responseReference;
                break;
            }
        }

        return response;
    }
}

    @Override
    public String getTemplateHtmlForm( Entry entry, boolean bDisplayFront )
    {
        if ( bDisplayFront )
        {
            return TEMPLATE_EDITION_FRONTOFFICE;
        }

        return TEMPLATE_EDITION_BACKOFFICE;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getTemplateCreate( Entry entry, boolean bDisplayFront )
    {
        return TEMPLATE_CREATE;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getTemplateModify( Entry entry, boolean bDisplayFront )
    {

        return TEMPLATE_MODIFY;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public AbstractGenAttUploadHandler getAsynchronousUploadHandler( )
    {
        return FormsAsynchronousUploadHandler.getHandler( );
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getUrlDownloadFile( int nResponseId, String strBaseUrl )
    {
        UrlItem url = new UrlItem( strBaseUrl + JSP_DOWNLOAD_FILE );
        url.addParameter( PARAMETER_ID_RESPONSE, nResponseId );

        return url.getUrl( );
    }

    /**
     * {@inheritDoc}
     */
    @Override
    protected boolean checkForImages( )
    {
        return false;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getTemplateEntryReadOnly( boolean bDisplayFront )
    {
        if ( bDisplayFront )
        {
            return TEMPLATE_READONLY_FRONTOFFICE;
        }

        return TEMPLATE_READONLY_BACKOFFICE;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean isResponseChanged( List<Response> listResponseReference, List<Response> listResponseNew )
    {
        return CollectionUtils.isNotEmpty( listResponseNew );
    }

    private PdfCell createPdfCell( FormResponseStep formResponseStep, FormDisplay formDisplay, int iterationNumber )
    {
        FormQuestionResponse formQuestionResponse = formResponseStep.getQuestions( ).stream( )
                .filter( fqr -> fqr.getQuestion( ).getEntry( ).isExportablePdf( ) )
                .filter( fqr -> fqr.getQuestion( ).getId( ) == formDisplay.getCompositeId( ) )
                .filter( fqr -> fqr.getQuestion( ).getIterationNumber( ) == iterationNumber ).findFirst( ).orElse( null );

        if ( formQuestionResponse != null )
        {
            String key = formQuestionResponse.getQuestion( ).getTitle( );
            List<String> listResponseValue = getResponseValue( formQuestionResponse, iterationNumber );
            if ( CollectionUtils.isNotEmpty( listResponseValue ) )
            {
                PdfCell cell = new PdfCell( );
                cell.setTitle( key );
                cell.setValue( listResponseValue.stream( ).filter( StringUtils::isNotEmpty ).collect( Collectors.joining( ";" ) ) );

    protected AbstractDayDistanceValidator( String strValidatorName, String strValidatorDisplayName, List<String> listAvailableEntryType )
    {
        super( strValidatorName, strValidatorDisplayName, listAvailableEntryType );
    }

    @Override
    public String getDisplayHtml( Control control )
    {
        Map<String, Object> model = new HashMap<>( );
        model.put( FormsConstants.PARAMETER_CONTROL_VALUE, control.getValue( ) );
        model.put( MARK_LABEL, getLabelKey( ) );
        model.put( MARK_HELP, getHelpKey( ) );

        HtmlTemplate htmlTemplateQuestion = AppTemplateService.getTemplate( TEMPLATE_DISPLAY_HTML, _locale, model );

        return htmlTemplateQuestion.getHtml( );
    }

    @Override
    public boolean validate( FormQuestionResponse questionResponse, Control control )
    {
        if ( questionResponse.getEntryResponse().isEmpty() ){
            return false;
        }
        Response response = questionResponse.getEntryResponse( ).get( 0 );
        if ( ! response.getResponseValue().isEmpty())
        {
            try
            {
                return validateControl(Integer.parseInt( control.getValue( ) ),

            daoUtil.setString( nIndex++, question.getTitle( ) );
            daoUtil.setString( nIndex++, question.getCode( ) );
            daoUtil.setString( nIndex++, question.getDescription( ) );
            daoUtil.setInt( nIndex++, question.getIdEntry( ) );
            daoUtil.setInt( nIndex++, question.getIdStep( ) );
            daoUtil.setBoolean( nIndex++, question.isVisibleMultiviewGlobal( ) );
            daoUtil.setBoolean( nIndex++, question.isVisibleMultiviewFormSelected( ) );
            daoUtil.setString( nIndex++, question.getColumnTitle( ) );
            daoUtil.setBoolean( nIndex++, question.isFiltrableMultiviewGlobal( ) );
            daoUtil.setBoolean( nIndex++, question.isFiltrableMultiviewFormSelected( ) );
            daoUtil.setInt( nIndex++, question.getMultiviewColumnOrder( ) );
            daoUtil.setInt( nIndex++, question.getExportDisplayOrder() );

            daoUtil.executeUpdate( );

    private Question dataToObject( DAOUtil daoUtil )
    {
        Question question = new Question( );

        question.setId( daoUtil.getInt( "id_question" ) );
        question.setTitle( daoUtil.getString( "title" ) );
        question.setCode( daoUtil.getString( "code" ) );
        question.setDescription( daoUtil.getString( "description" ) );
        question.setIdEntry( daoUtil.getInt( "id_entry" ) );
        question.setIdStep( daoUtil.getInt( "id_step" ) );
        question.setVisibleMultiviewGlobal( daoUtil.getBoolean( "is_visible_multiview_global" ) );
        question.setVisibleMultiviewFormSelected( daoUtil.getBoolean( "is_visible_multiview_form_selected" ) );
        question.setColumnTitle( daoUtil.getString( "column_title" ) );
        question.setFiltrableMultiviewGlobal( daoUtil.getBoolean( "is_filterable_multiview_global" ) );
        question.setFiltrableMultiviewFormSelected( daoUtil.getBoolean( "is_filterable_multiview_form_selected" ) );
        question.setMultiviewColumnOrder( daoUtil.getInt( "multiview_column_order" ) );
        question.setExportDisplayOrder( daoUtil.getInt( "export_display_order" ) );

    @Override
    public String getTemplateHtmlForm( Entry entry, boolean bDisplayFront )
    {
        if ( bDisplayFront )
        {
            return TEMPLATE_EDITION_FRONTOFFICE;
        }

        return TEMPLATE_EDITION_BACKOFFICE;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getTemplateCreate( Entry entry, boolean bDisplayFront )
    {
        return TEMPLATE_CREATE;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getTemplateModify( Entry entry, boolean bDisplayFront )
    {
        return TEMPLATE_MODIFY;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getTemplateEntryReadOnly( boolean bDisplayFront )
    {
        if ( bDisplayFront )
        {
            return TEMPLATE_READONLY_FRONTOFFICE;
        }
        return TEMPLATE_READONLY_BACKOFFICE;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean isResponseChanged( List<Response> listResponseReference, List<Response> listResponseNew )
    {
        String strResponseReference = listResponseReference.get( 0 ).getResponseValue( );
        String strResponseNew = listResponseNew.get( 0 ).getResponseValue( );

        if ( strResponseReference == null )
        {
            return strResponseNew != null;
        }

        return !strResponseReference.equals( strResponseNew );
    }
}

        List<FormQuestionResponse> list = new ArrayList<>( );
        int nlistIdFormResponseSize = listIdFormResponse.size( );

        if ( nlistIdFormResponseSize > 0 )
        {
            StringBuilder sbSQL = new StringBuilder( SQL_QUERY_SELECT_BY_LIST_FORM_RESPONSE );

            for ( int i = 1; i < nlistIdFormResponseSize; i++ )
            {
                sbSQL.append( SQL_ADITIONAL_PARAMETER );
            }

            sbSQL.append( SQL_CLOSE_PARENTHESIS );

            try ( DAOUtil daoUtil = new DAOUtil( sbSQL.toString( ), plugin ) )
            {

                for ( int i = 0; i < nlistIdFormResponseSize; i++ )
                {
                    daoUtil.setInt( i + 1, listIdFormResponse.get( i ) );
                }

                daoUtil.executeQuery( );

                while ( daoUtil.next( ) )
                {
                    list.add( dataToObject( daoUtil ) );
                }
            }
        }
        return list;
    }

        List<FormResponse> formResponseResult= new ArrayList<>( );
        if( CollectionUtils.isNotEmpty( formResponseList) ) 
        {
        	List<Form> listForm=FormHome.getFormByPrimaryKeyList( formResponseList.stream()
        			.map( FormResponse::getFormId )
        			.collect(ArrayList<Integer>::new, ArrayList::add, ArrayList::addAll));
        	
        	List<Integer>  listIdFormByRole=listForm.stream()
        					 .filter(Form::isAccessToResponsesByRole )
        					 .map(Form::getId )
        					 .collect(ArrayList<Integer>::new, ArrayList::add, ArrayList::addAll);
        	
        	formResponseList.forEach(( FormResponse frmRsp ) -> {
        		if( isAuthorized( listIdFormByRole,  frmRsp,  user ))
        		{
        			formResponseResult.add( frmRsp );

    public HorizontalBreadcrumb( String strBreadcrumbName, String strBreadcrumbDisplayName )
    {
        _strBreadcrumbBeanName = strBreadcrumbName;
        _strBreadcrumbDisplayBeanName = I18nService.getLocalizedString( strBreadcrumbDisplayName, I18nService.getDefaultLocale( ) );
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getBreadcrumbBeanName( )
    {
        return _strBreadcrumbBeanName;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getBreadcrumbDisplayName( )
    {
        return _strBreadcrumbDisplayBeanName;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getTopHtml( HttpServletRequest request, FormResponseManager formResponseManager )
    {
        Map<String, Object> model = new HashMap<>( );
        model.put( FormsConstants.MARK_LIST_STEPS, formResponseManager.getValidatedSteps( ) );
        HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_BREADCRUMB_HTML, I18nService.getDefaultLocale( ), model );

        return template.getHtml( );
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getBottomHtml( HttpServletRequest request, FormResponseManager formResponseManager )
    {
        return null;
    }

    @Override
    public String getTemplateHtmlForm( Entry entry, boolean bDisplayFront )
    {
        if ( bDisplayFront )
        {
            return TEMPLATE_EDITION_FRONTOFFICE;
        }

        return TEMPLATE_EDITION_BACKOFFICE;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getTemplateCreate( Entry entry, boolean bDisplayFront )
    {
        return TEMPLATE_CREATE;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getTemplateModify( Entry entry, boolean bDisplayFront )
    {

        return TEMPLATE_MODIFY;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public AbstractGenAttUploadHandler getAsynchronousUploadHandler( )
    {
        return FormsAsynchronousUploadHandler.getHandler( );
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getUrlDownloadFile( int nResponseId, String strBaseUrl )
    {
        UrlItem url = new UrlItem( strBaseUrl + JSP_DOWNLOAD_FILE );
        url.addParameter( PARAMETER_ID_RESPONSE, nResponseId );

        return url.getUrl( );
    }

    /**
     * {@inheritDoc}
     */
    @Override
    protected boolean checkForImages( )
    {
        return false;

        }

        boolean bAllResponsesEquals = true;

        for ( Response responseNew : listResponseNew )
        {
            Response responseReference = findReferenceResponseAssociatedToNewResponse( responseNew, listResponseReference );

            if ( responseReference == null || !responseReference.getResponseValue( ).equals( responseNew.getResponseValue( ) ) )
            {
                bAllResponsesEquals = false;
                break;
            }
        }

        return !bAllResponsesEquals;
    }

    /**
     * Finds the reference response associated to the new response
     * 
     * @param responseNew
     *            the new response
     * @param listResponseReference
     *            the list of reference responses
     * @return the found response or {@code null} if not found
     */
    private Response findReferenceResponseAssociatedToNewResponse( Response responseNew, List<Response> listResponseReference )
    {
        Response response = null;

        for ( Response responseReference : listResponseReference )
        {
            if ( responseReference.getField( ).getValue( ).equals( responseNew.getField( ).getValue( ) ) )
            {
                response = responseReference;
                break;
            }
        }

        return response;
    }
}

    @Override
    public String buildFormColumnHeaderTemplate( String strSortUrl, Locale locale )
    {
        Map<String, Object> model = new LinkedHashMap<>( );
        model.put( MARK_ENTRY_VALUE_COLUMN_TITLE, getFormColumnTitle( locale ) );
        model.put( MARK_ENTRY_VALUE_COLUMN_POSITION, getPosition( ) );

        model.put( MARK_COLUMN_SORT_ATTRIBUTE, String.format( FormEntryNameConstants.COLUMN_ENTRY_GEOLOC_VALUE_PATTERN_ADDR, getPosition( ) ) );
        model.put( MARK_SORT_URL, buildCompleteSortUrl( strSortUrl ) );

        String strColumnHeaderTemplate = AppTemplateService.getTemplate( FORM_COLUMN_HEADER_TEMPLATE, locale, model ).getHtml( );
        setFormColumnHeaderTemplate( strColumnHeaderTemplate );

        return strColumnHeaderTemplate;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String buildFormColumnCellTemplate( FormColumnCell formColumnCell, Locale locale )
    {
        String strEntryGeoJSON = StringUtils.EMPTY;

    @Override
    public String getTemplateHtmlForm( Entry entry, boolean bDisplayFront )
    {
        if ( bDisplayFront )
        {
            return TEMPLATE_EDITION_FRONTOFFICE;
        }

        return TEMPLATE_EDITION_BACKOFFICE;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getTemplateCreate( Entry entry, boolean bDisplayFront )
    {
        return TEMPLATE_CREATE;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getTemplateModify( Entry entry, boolean bDisplayFront )
    {
        return TEMPLATE_MODIFY;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getTemplateEntryReadOnly( boolean bDisplayFront )
    {
        if ( bDisplayFront )
        {
            return TEMPLATE_READONLY_FRONTOFFICE;
        }

        return TEMPLATE_READONLY_BACKOFFICE;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean isResponseChanged( List<Response> listResponseReference, List<Response> listResponseNew )
    {
        if ( listResponseReference.size( ) != listResponseNew.size( ) )
        {
            return true;
        }

    public String modifyFilterableQuestions( HttpServletRequest request ) throws AccessDeniedException
    {
        int nId = NumberUtils.toInt( request.getParameter( FormsConstants.PARAMETER_ID_FORM ), FormsConstants.DEFAULT_ID_VALUE );
        
        if ( nId == FormsConstants.DEFAULT_ID_VALUE )
        {
            return redirect( request, VIEW_MANAGE_FORMS );
        }
        checkUserPermission( Form.RESOURCE_TYPE, String.valueOf( nId ), FormsResourceIdService.PERMISSION_MODIFY, request, ACTION_MANAGE_MULTIVIEW );

        Form formToBeModified = FormHome.findByPrimaryKey( nId );

        if ( formToBeModified == null )
        {
            return redirect( request, VIEW_MANAGE_FORMS );
        }
        
        List<Question> questionList = QuestionHome.getListQuestionByIdForm( formToBeModified.getId( ) );

        for ( Question question : questionList )
        {

        String strGeoJSONValue = String.format( FormEntryNameConstants.COLUMN_ENTRY_CARTO_VALUE_PATTERN_GEOJSON, getFormColumn( ).getFormColumnPosition( ) );

        for ( String strFormColumnEntryCode : getListEntryCode( getFormColumn( ) ) )
        {
            Map<String, String> listFields = getEntryCodeFields( strFormColumnEntryCode, formResponseSearchItem );
            for ( Map.Entry<String, String> field : listFields.entrySet( ) )
            {
                String [ ] splits = field.getKey( ).split( "_" );
                String strIdField = splits [splits.length - 1];
                int nIdField = Integer.parseInt( strIdField );
                Field fieldGenatt = FieldHome.findByPrimaryKey( nIdField );
                switch( fieldGenatt.getValue( ) )
                {
                    case CONSTANT_FIELD_GEOJSON:

    @View( VIEW_MANAGE_MULTIVIEW )
    public String getManageMultiview( HttpServletRequest request ) throws AccessDeniedException
    {
        int nId = NumberUtils.toInt( request.getParameter( FormsConstants.PARAMETER_ID_FORM ), FormsConstants.DEFAULT_ID_VALUE );

        if ( nId == FormsConstants.DEFAULT_ID_VALUE )
        {
            return redirect( request, VIEW_MANAGE_FORMS );
        }

        checkUserPermission( Form.RESOURCE_TYPE, String.valueOf( nId ), FormsResourceIdService.PERMISSION_MODIFY_PARAMS, request, null );

        Form formToBeModified = FormHome.findByPrimaryKey( nId );

        if ( formToBeModified == null )
        {
            return redirect( request, VIEW_MANAGE_FORMS );
        }
        
        List<Question> questionList = QuestionHome.getQuestionListByIdFormInQuestionOrder( formToBeModified.getId( ) );

    public EntryTypeDateDisplayService( String strEntryServiceName )
    {
        _strEntryServiceName = strEntryServiceName;
    }

    /**
     * Return the completed model
     * 
     * @param entry
     *            The given entry
     * @param locale
     *            The given locale
     * @param model
     *            The given model
     * @return the completed model
     */
    private Map<String, Object> setModel( Entry entry, Locale locale, Map<String, Object> model )
    {
        model.put( FormsConstants.QUESTION_ENTRY_MARKER, entry );
        model.put( LOCALE_MARKER, locale );

        return model;
    }

    @Override
    public String getDisplayServiceName( )
    {
        return _strEntryServiceName;
    }

    @Override
    public String getEntryTemplateDisplay( HttpServletRequest request, Entry entry, Locale locale, Map<String, Object> model, DisplayType displayType )
    {
        String strEntryHtml = StringUtils.EMPTY;
        IEntryTypeService service = EntryTypeServiceManager.getEntryTypeService( entry );

    @Override
    public String getTemplateHtmlForm( Entry entry, boolean bDisplayFront )
    {
        if ( bDisplayFront )
        {
            return TEMPLATE_EDITION_FRONTOFFICE;
        }

        return TEMPLATE_EDITION_BACKOFFICE;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getTemplateCreate( Entry entry, boolean bDisplayFront )
    {
        return TEMPLATE_CREATE;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getTemplateModify( Entry entry, boolean bDisplayFront )
    {
        return TEMPLATE_MODIFY;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getTemplateEntryReadOnly( boolean bDisplayFront )
    {
        if ( bDisplayFront )
        {
            return TEMPLATE_READONLY_FRONTOFFICE;
        }

        return TEMPLATE_READONLY_BACKOFFICE;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean isResponseChanged( List<Response> listResponseReference, List<Response> listResponseNew )
    {
        String strResponseReference = listResponseReference.get( 0 ).getResponseValue( );

    public String doMoveUpExportConfig( HttpServletRequest request )
    {
        int idConfig = NumberUtils.toInt( request.getParameter( PARAMETER_ID_CONFIG ), FormsConstants.DEFAULT_ID_VALUE );
        int idForm = NumberUtils.toInt( request.getParameter( FormsConstants.PARAMETER_ID_FORM ), FormsConstants.DEFAULT_ID_VALUE );

        if ( idConfig == FormsConstants.DEFAULT_ID_VALUE )
        {
            Map<String, String> mapParameters = new LinkedHashMap<>( );
            mapParameters.put( FormsConstants.PARAMETER_ID_FORM, String.valueOf( idForm ) );

            return redirect( request, VIEW_MANAGE_EXPORT, mapParameters );
        }

        List<FormExportConfig> existingConfigList = FormExportConfigHome.findByForm( idForm );

        FormExportConfig configMovedUp = FormExportConfigHome.findByPrimaryKey( idConfig );

        for ( FileItem fileItem : listUploadedFileItems )
        {
        	if (fileItem != null)
            {
            	File file = new File( );
                file.setTitle( fileItem.getName( ) );
                file.setSize( ( fileItem.getSize( ) < Integer.MAX_VALUE ) ? (int) fileItem.getSize( ) : Integer.MAX_VALUE );
                file.setMimeType( FileSystemUtil.getMIMEType( file.getTitle( ) ) );

                PhysicalFile physicalFile = new PhysicalFile( );
                physicalFile.setValue( fileItem.get( ) );
                file.setPhysicalFile( physicalFile );
                return file;
            }
        }

    public synchronized XPage doAddIteration( HttpServletRequest request ) throws SiteMessageException, UserNotSignedException
    {
        IsRequestComingFromAction = true;

        try
        {
            boolean bSessionLost = isSessionLost( );
            findFormFrom( request );
            if ( bSessionLost )
            {
                addWarning( MESSAGE_WARNING_LOST_SESSION, getLocale( request ) );
                return getStepView(  request );
            }
            if ( !isFormSessionValid( request ) )
            {
                addWarning( MESSAGE_WARNING_INVALID_FORM_SESSION, getLocale( request ) );
                return getStepView( request );
            }
            FormsResponseUtils.fillResponseManagerWithResponses( request, false, _formResponseManager, _stepDisplayTree.getQuestions( ), false );
        }
        catch( FormNotFoundException | QuestionValidationException exception )
        {
            return getStepView(  request );
        }

        field.setParentEntry( entry );

        String strError = getFieldData( request, field );

        if ( strError != null )
        {
            return redirect( request, strError );
        }
        
        if ( imageFileItem != null && imageFileItem.getSize( ) > 0 )
        {
            try
            {
                String strFileStoreKey = ImageResourceManager.addImageResource( FileImagePublicService.IMAGE_RESOURCE_TYPE_ID, imageFileItem );
                File fileImage = new File( );
                fileImage.setFileKey( strFileStoreKey );
                field.setFileImage( fileImage );
            }
            catch ( Exception e ) 
            {
            	AppLogService.error( MESSAGE_ERROR_FILE_IMAGE, e );
                throw new AppException( MESSAGE_ERROR_FILE_IMAGE, e );
            }
        }

        FieldHome.create( field );