userField = new AdminUserField(  );
            userField.setIdUserField( daoUtil.getInt( 1 ) );
            userField.setValue( daoUtil.getString( 6 ) );

            // USER
            AdminUser user = new AdminUser(  );
            user.setUserId( daoUtil.getInt( 2 ) );
            user.setAccessCode( daoUtil.getString( 7 ) );
            user.setLastName( daoUtil.getString( 8 ) );
            user.setFirstName( daoUtil.getString( 9 ) );
            user.setEmail( daoUtil.getString( 10 ) );
            user.setStatus( daoUtil.getInt( 11 ) );
            user.setLocale( new Locale( daoUtil.getString( 12 ) ) );
            user.setUserLevel( daoUtil.getInt( 13 ) );
            userField.setUser( user );

            // ATTRIBUTE
            IAttribute attribute = null;

            try
            {
                attribute = (IAttribute) Class.forName( daoUtil.getString( 14 ) ).newInstance(  );
            }
            catch ( ClassNotFoundException e )
            {
                // class doesn't exist
                AppLogService.error( e );
            }
            catch ( InstantiationException e )
            {
                // Class is abstract or is an interface or haven't accessible
                // builder
                AppLogService.error( e );
            }
            catch ( IllegalAccessException e )
            {
                // can't access to the class
                AppLogService.error( e );
            }

            attribute.setIdAttribute( daoUtil.getInt( 3 ) );
            attribute.setTitle( daoUtil.getString( 15 ) );
            attribute.setHelpMessage( daoUtil.getString( 16 ) );
            attribute.setMandatory( daoUtil.getBoolean( 17 ) );
            attribute.setPosition( daoUtil.getInt( 18 ) );
            attribute.setAttributeType( new Locale( daoUtil.getString( 12 ) ) );
            userField.setAttribute( attribute );

            // ATTRIBUTEFIELD
            AttributeField attributeField = new AttributeField(  );
            attributeField.setIdField( daoUtil.getInt( 4 ) );
            attributeField.setTitle( daoUtil.getString( 19 ) );
            attributeField.setValue( daoUtil.getString( 20 ) );
            attributeField.setDefaultValue( daoUtil.getBoolean( 21 ) );
            attributeField.setHeight( daoUtil.getInt( 22 ) );
            attributeField.setWidth( daoUtil.getInt( 23 ) );
            attributeField.setMaxSizeEnter( daoUtil.getInt( 24 ) );
            attributeField.setMultiple( daoUtil.getBoolean( 25 ) );
            attributeField.setPosition( daoUtil.getInt( 26 ) );
            userField.setAttributeField( attributeField );

            // FILE
            if ( daoUtil.getObject( 5 ) != null ) // f.id_file
            {
                File file = new File(  );
                file.setIdFile( daoUtil.getInt( 5 ) ); // f.id_file
                userField.setFile( file );
            }

    public String getModifyPortletStatus( HttpServletRequest request ) throws AccessDeniedException
    {
        String strPortletId = request.getParameter( Parameters.PORTLET_ID );
        String strStatus = request.getParameter( PORTLET_STATUS );
        if ( !StringUtils.isNumeric( strPortletId ) || !StringUtils.isNumeric( strStatus ) )
        {
            return AdminMessageService.getMessageUrl( request, Messages.MANDATORY_FIELDS, AdminMessage.TYPE_ERROR);
        }
        int nPortletId = Integer.parseInt( strPortletId );
        Portlet portlet = null;
        try
        {
            portlet = PortletHome.findByPrimaryKey( nPortletId );
        } catch (NullPointerException e)
        {
            AppLogService.error( "Error looking for portlet with id " + nPortletId, e );
        }
        if ( portlet == null || portlet.getId( ) != nPortletId )
        {
            return AdminMessageService.getMessageUrl( request, Messages.MESSAGE_INVALID_ENTRY, new Object[] { nPortletId }, AdminMessage.TYPE_ERROR);
        }
        int nStatus = Integer.parseInt( strStatus );
        if ( nStatus != Portlet.STATUS_PUBLISHED && nStatus != Portlet.STATUS_UNPUBLISHED )
        {
            return AdminMessageService.getMessageUrl( request, Messages.MESSAGE_INVALID_ENTRY, new Object[] { nStatus }, AdminMessage.TYPE_ERROR);
        }
        AdminUser user = AdminUserService.getAdminUser( request );
        if ( !RBACService.isAuthorized( PortletType.RESOURCE_TYPE, portlet.getPortletTypeId(  ),
                PortletResourceIdService.PERMISSION_MANAGE, user ) )
        {
            throw new AccessDeniedException( "User " + user + " is not authorized to permission " + PortletResourceIdService.PERMISSION_MANAGE
                    + " on portlet " + nPortletId );
        }

        attributeType.setLabelType( PROPERTY_TYPE_CHECKBOX );
        setAttributeType( attributeType );
    }

    /**
     * Get the data of the user fields
     * @param request HttpServletRequest
     * @param user user
     * @return user field data
     */
    @Override
    public List<AdminUserField> getUserFieldsData( HttpServletRequest request, AdminUser user )
    {
        String[] strValues = request.getParameterValues( PARAMETER_ATTRIBUTE + CONSTANT_UNDERSCORE +
                getIdAttribute(  ) );

        return getUserFieldsData( strValues, user );
    }

    /**
     * Get the data of the user fields
     * @param strValues Values
     * @param user user
     * @return user field data
     */
    @Override
    public List<AdminUserField> getUserFieldsData( String[] strValues, AdminUser user )
    {
        List<AdminUserField> listUserFields = new ArrayList<AdminUserField>(  );

        if ( strValues != null )
        {
            for ( String strValue : strValues )
            {
                AdminUserField userField = new AdminUserField(  );
                AttributeField attributeField;

                if ( StringUtils.isNotBlank( strValue ) && StringUtils.isNumeric( strValue ) )
                {
                    int nIdField = Integer.parseInt( strValue );
                    attributeField = AttributeFieldService.getInstance(  ).getAttributeField( nIdField );
                }
                else
                {
                    attributeField = new AttributeField(  );
                    attributeField.setAttribute( this );
                    attributeField.setTitle( strValue );
                    attributeField.setValue( strValue );
                }

                userField.setUser( user );
                userField.setAttribute( this );
                userField.setAttributeField( attributeField );
                userField.setValue( attributeField.getTitle(  ) );

                listUserFields.add( userField );
            }
        }

        return listUserFields;
    }

    /**
     * Get whether the attribute is anonymizable.
     * @return True if the attribute can be anonymized, false otherwise.
     */
    @Override
    public boolean isAnonymizable(  )
    {
        return false;
    }
}

    public void store( IAdminDashboardComponent dashboardComponent )
    {
        DAOUtil daoUtil = new DAOUtil( SQL_QUERY_UPDATE );

        int nIndex = setInsertOrUpdateValues( 1, dashboardComponent, daoUtil );
        daoUtil.setString( nIndex, dashboardComponent.getName(  ) );

        daoUtil.executeUpdate(  );

        daoUtil.free(  );
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public List<Integer> selectColumns(  )
    {
        List<Integer> listColumns = new ArrayList<Integer>(  );

        DAOUtil daoUtil = new DAOUtil( SQL_QUERY_SELECT_COLUMNS );

        daoUtil.executeQuery(  );

        while ( daoUtil.next(  ) )
        {
            listColumns.add( daoUtil.getInt( 1 ) );
        }

        daoUtil.free(  );

        return listColumns;
    }

    /**
     * Loads component data from daoUtil
     * @param component the component
     * @param daoUtil the daoutil
     */
    private void load( IDashboardComponent component, DAOUtil daoUtil )
    {
        int nIndex = 1;
        component.setName( daoUtil.getString( nIndex++ ) );
        component.setOrder( daoUtil.getInt( nIndex++ ) );
        component.setZone( daoUtil.getInt( nIndex++ ) );
    }

    /**
     * Sets daoUtil values from component
     * @param nStartIndex the start index
     * @param component the component
     * @param daoUtil daoutil
     * @return the end index
     */
    private int setInsertOrUpdateValues( int nStartIndex, IDashboardComponent component, DAOUtil daoUtil )
    {
        int nIndex = nStartIndex;
        daoUtil.setInt( nIndex++, component.getOrder(  ) );
        daoUtil.setInt( nIndex++, component.getZone(  ) );

        return nIndex;
    }

    /**
     * Builds sql filter
     * @param sbSQL the buffer
     * @param filter the filter
     */
    private void buildSQLFilter( StringBuilder sbSQL, AdminDashboardFilter filter )

        DAOUtil daoUtil = new DAOUtil( SQL_QUERY_SELECTALL );
        daoUtil.executeQuery(  );

        while ( daoUtil.next(  ) )
        {
            Page page = new Page(  );

            page.setId( daoUtil.getInt( 1 ) );
            page.setParentPageId( daoUtil.getInt( 2 ) );
            page.setOrigParentPageId( daoUtil.getInt( 2 ) );
            page.setName( daoUtil.getString( 3 ) );
            page.setDescription( daoUtil.getString( 4 ) );
            page.setDateUpdate( daoUtil.getTimestamp( 5 ) );
            page.setOrder( daoUtil.getInt( 6 ) );
            page.setStatus( daoUtil.getInt( 7 ) );
            page.setRole( daoUtil.getString( 8 ) );
            page.setCodeTheme( daoUtil.getString( 9 ) );
            page.setImageContent( daoUtil.getBytes( 10 ) );
            page.setMimeType( daoUtil.getString( 11 ) );
            page.setMetaKeywords( daoUtil.getString( 12 ) );
            page.setMetaDescription( daoUtil.getString( 13 ) );

            if ( daoUtil.getObject( 14 ) != null )
            {
                page.setIdAuthorizationNode( daoUtil.getInt( 14 ) );
            }

            pageList.add( page );
        }

        daoUtil.free(  );

        return pageList;
    }

    /**
     * {@inheritDoc}
     */
    public void invalidatePage( int nPageId )

        for ( AdminUser user : AdminUserHome.findByRight( strIdRight ) )
        {
            //Add users with higher level then connected user or add all users if connected user is administrator
            if ( ( user.getUserLevel(  ) > getUser(  ).getUserLevel(  ) ) || ( getUser(  ).isAdmin(  ) ) )
            {
                listAssignedUsers.add( user );
            }
        }

        List<AdminUser> listFilteredUsers = AdminUserService.getFilteredUsersInterface( listAssignedUsers, request,
                model, url );

        // AVAILABLE USERS
        ReferenceList listAvailableUsers = new ReferenceList(  );
        ReferenceItem itemUser = null;
        boolean bAssigned;

        for ( AdminUser user : AdminUserHome.findUserList(  ) )
        {
            itemUser = new ReferenceItem(  );
            itemUser.setCode( Integer.toString( user.getUserId(  ) ) );
            itemUser.setName( user.getAccessCode(  ) + "(" + user.getFirstName(  ) + " " + user.getLastName(  ) + ")" );
            bAssigned = Boolean.FALSE;

            for ( AdminUser assignedUser : listAssignedUsers )
            {
                if ( Integer.toString( assignedUser.getUserId(  ) ).equals( itemUser.getCode(  ) ) )
                {
                    bAssigned = Boolean.TRUE;

                    break;
                }
            }

            //Add users with higher level then connected user or add all users if connected user is administrator
            if ( !bAssigned &&
                    ( ( user.getUserLevel(  ) > getUser(  ).getUserLevel(  ) ) || ( getUser(  ).isAdmin(  ) ) ) &&

    }

    /**
     * Set the data of the attribute
     * @param request HttpServletRequest
     * @return null if there are no errors
     */
    @Override
    public String setAttributeData( HttpServletRequest request )
    {
        String strTitle = request.getParameter( PARAMETER_TITLE );
        String strHelpMessage = ( request.getParameter( PARAMETER_HELP_MESSAGE ) != null )
            ? request.getParameter( PARAMETER_HELP_MESSAGE ).trim(  ) : null;
        String strIsShownInSearch = request.getParameter( PARAMETER_IS_SHOWN_IN_SEARCH );
        String strIsShownInResultList = request.getParameter( PARAMETER_IS_SHOWN_IN_RESULT_LIST );
        String strMandatory = request.getParameter( PARAMETER_MANDATORY );
        String strFieldInLine = request.getParameter( PARAMETER_IS_FIELD_IN_LINE );

        if ( StringUtils.isNotBlank( strTitle ) )
        {
            setTitle( strTitle );
            setHelpMessage( strHelpMessage );
            setMandatory( strMandatory != null );
            setShownInSearch( strIsShownInSearch != null );
            setShownInResultList( strIsShownInResultList != null );
            setFieldInLine( strFieldInLine != null );

            return null;
        }

        return AdminMessageService.getMessageUrl( request, Messages.MANDATORY_FIELDS, AdminMessage.TYPE_STOP );
    }

    /**
     * Set attribute type
     * @param locale locale
     */
    @Override
    public void setAttributeType( Locale locale )
    {
        AttributeType attributeType = new AttributeType(  );
        attributeType.setLocale( locale );
        attributeType.setClassName( this.getClass(  ).getName(  ) );
        attributeType.setLabelType( PROPERTY_TYPE_CHECKBOX );

        DAOUtil daoUtil = new DAOUtil( SQL_QUERY_SELECT_ALL );
        daoUtil.executeQuery(  );

        while ( daoUtil.next(  ) )
        {
            int nIndex = 1;
            IAttribute attribute = null;

            try
            {
                attribute = (IAttribute) Class.forName( daoUtil.getString( nIndex++ ) ).newInstance(  );
            }
            catch ( ClassNotFoundException e )
            {
                // class doesn't exist
                AppLogService.error( e );
            }
            catch ( InstantiationException e )
            {
                // Class is abstract or is an interface or haven't accessible
                // builder
                AppLogService.error( e );
            }
            catch ( IllegalAccessException e )
            {
                // can't access to the class
                AppLogService.error( e );
            }

            attribute.setIdAttribute( daoUtil.getInt( nIndex++ ) );
            attribute.setTitle( daoUtil.getString( nIndex++ ) );
            attribute.setHelpMessage( daoUtil.getString( nIndex++ ) );
            attribute.setMandatory( daoUtil.getBoolean( nIndex++ ) );
            attribute.setShownInSearch( daoUtil.getBoolean( nIndex++ ) );
            attribute.setShownInResultList( daoUtil.getBoolean( nIndex++ ) );
            attribute.setFieldInLine( daoUtil.getBoolean( nIndex++ ) );
            attribute.setPosition( daoUtil.getInt( nIndex++ ) );
            attribute.setAnonymize( daoUtil.getBoolean( nIndex++ ) );

    public String getRemovePortlet( HttpServletRequest request ) throws AccessDeniedException
    {
        String strPortletId = request.getParameter( Parameters.PORTLET_ID );
        if ( !StringUtils.isNumeric( strPortletId ) )
        {
            return AdminMessageService.getMessageUrl( request, Messages.MANDATORY_FIELDS, AdminMessage.TYPE_ERROR);
        }
        int nPortletId = Integer.parseInt( strPortletId );
        Portlet portlet = null;
        try
        {
            portlet = PortletHome.findByPrimaryKey( nPortletId );
        } catch (NullPointerException e)
        {
            AppLogService.error( "Error looking for portlet with id " + nPortletId, e );
        }
        if ( portlet == null || portlet.getId( ) != nPortletId )
        {
            return AdminMessageService.getMessageUrl( request, Messages.MESSAGE_INVALID_ENTRY, new Object[] { nPortletId }, AdminMessage.TYPE_ERROR);
        }
        AdminUser user = AdminUserService.getAdminUser( request );
        if ( !RBACService.isAuthorized( PortletType.RESOURCE_TYPE, portlet.getPortletTypeId(  ),
                PortletResourceIdService.PERMISSION_MANAGE, user ) )
        {
            throw new AccessDeniedException( "User " + user + " is not authorized to permission " + PortletResourceIdService.PERMISSION_MANAGE
                    + " on portlet " + nPortletId );
        }

            try
            {
                attribute = (IAttribute) Class.forName( daoUtil.getString( nIndex++ ) ).newInstance(  );
            }
            catch ( ClassNotFoundException e )
            {
                // class doesn't exist
                AppLogService.error( e );
            }
            catch ( InstantiationException e )
            {
                // Class is abstract or is an interface or haven't accessible
                // builder
                AppLogService.error( e );
            }
            catch ( IllegalAccessException e )
            {
                // can't access to rhe class
                AppLogService.error( e );
            }

            attribute.setIdAttribute( daoUtil.getInt( nIndex++ ) );
            attribute.setTitle( daoUtil.getString( nIndex++ ) );
            attribute.setHelpMessage( daoUtil.getString( nIndex++ ) );
            attribute.setMandatory( daoUtil.getBoolean( nIndex++ ) );
            attribute.setShownInSearch( daoUtil.getBoolean( nIndex++ ) );
            attribute.setShownInResultList( daoUtil.getBoolean( nIndex++ ) );
            attribute.setFieldInLine( daoUtil.getBoolean( nIndex++ ) );
            attribute.setPosition( daoUtil.getInt( nIndex++ ) );
            attribute.setAttributeType( locale );

            Plugin plugin = PluginService.getPlugin( daoUtil.getString( nIndex++ ) );

            nIndex = 1;

            IAttribute attribute = null;

            try
            {
                attribute = (IAttribute) Class.forName( daoUtil.getString( nIndex++ ) ).newInstance(  );
            }
            catch ( ClassNotFoundException e )
            {
                // class doesn't exist
                AppLogService.error( e );
            }
            catch ( InstantiationException e )
            {
                // Class is abstract or is an interface or haven't accessible
                // builder
                AppLogService.error( e );
            }
            catch ( IllegalAccessException e )
            {
                // can't access to rhe class
                AppLogService.error( e );
            }

            attribute.setIdAttribute( daoUtil.getInt( nIndex++ ) );
            attribute.setTitle( daoUtil.getString( nIndex++ ) );
            attribute.setHelpMessage( daoUtil.getString( nIndex++ ) );
            attribute.setMandatory( daoUtil.getBoolean( nIndex++ ) );
            attribute.setShownInSearch( daoUtil.getBoolean( nIndex++ ) );
            attribute.setShownInResultList( daoUtil.getBoolean( nIndex++ ) );
            attribute.setFieldInLine( daoUtil.getBoolean( nIndex++ ) );
            attribute.setPosition( daoUtil.getInt( nIndex++ ) );
            attribute.setAttributeType( locale );

    }

    /**
     * Returns the name of the plugin
     *
     * @return the plugin name as a String
     */
    public String getName(  )
    {
        return _strName;
    }

    /**
     * Sets the name of the plugin
     *
     * @param strName The plugin name
     */
    public void setName( String strName )
    {
        _strName = strName;
    }

    /**
     * Returns the version of the plugin
     *
     * @return the plugin version as a String
     */
    public String getVersion(  )
    {
        return _strVersion;
    }

    /**
     * Sets the version plugin name
     * @param strVersion The version
     */
    public void setVersion( String strVersion )
    {
        _strVersion = strVersion;
    }

    /**
     * Returns the description of the plugin
     *
     * @return the plugin description as a String
     */
    public String getDescription(  )
    {
        return _strDescription;
    }

    /**
     * Sets the description of the plugin
     *
     * @param strDescription The description
     */
    public void setDescription( String strDescription )
    {
        _strDescription = strDescription;
    }

    /**
     * Returns the Provider of the plugin
     *
     * @return the plugin Provider as a String
     */
    public String getProvider(  )
    {
        return _strProvider;
    }

    /**
     * Sets the provider name
     *
     * @param strProvider The provider name
     */
    public void setProvider( String strProvider )
    {
        _strProvider = strProvider;
    }

    /**
     * Returns the Provider's URL of the plugin
     *
     * @return the plugin Provider's URL as a String
     */
    public String getProviderUrl(  )
    {
        return _strProviderUrl;
    }

    /**
     * Sets the provider url
     *
     * @param strProviderUrl the name of the provider
     */
    public void setProviderUrl( String strProviderUrl )
    {
        _strProviderUrl = strProviderUrl;
    }

    /**
     * Returns the Icon's URL of the plugin
     *
     * @return the plugin Icon's URL as a String
     */
    public String getIconUrl(  )
    {
        return _strIconUrl;
    }

    /**
     * Sets the url of the plugin's icon
     *
     * @param strIconUrl The url of icon
     */
    public void setIconUrl( String strIconUrl )
    {
        _strIconUrl = strIconUrl;
    }

    /**
     * Returns the Documentation's URL of the plugin
     *
     * @return the plugin Documentation's URL as a String
     */
    public String getDocumentationUrl(  )
    {
        return _strDocumentationUrl;
    }

    /**
     * Sets the url of the plugin's Documentation
     *
     * @param strDocumentationUrl The documentation Url
     */
    public void setDocumentationUrl( String strDocumentationUrl )
    {
        _strDocumentationUrl = strDocumentationUrl;
    }

    /**
     * Returns the Copyright of the plugin
     *
     * @return the plugin Copyright as a String
     */
    public String getCopyright(  )
    {
        return _strCopyright;
    }

    /**
     * Sets the copyright
     *
     * @param strCopyright The copyright
     */
    public void setCopyright( String strCopyright )
    {
        _strCopyright = strCopyright;
    }

    /**
     * Returns the main Class of the plugin
     *
     * @return the Class as a String
     */
    public String getServiceClass(  )

            right = new Right(  );
            right.setId( daoUtil.getString( 1 ) );
            right.setNameKey( daoUtil.getString( 2 ) );
            right.setLevel( daoUtil.getInt( 3 ) );
            right.setUrl( daoUtil.getString( 4 ) );
            right.setDescriptionKey( daoUtil.getString( 5 ) );
            right.setPluginName( daoUtil.getString( 6 ) );
            right.setFeatureGroup( daoUtil.getString( 7 ) );
            right.setIconUrl( daoUtil.getString( 8 ) );
            right.setDocumentationUrl( daoUtil.getString( 9 ) );
            right.setOrder( daoUtil.getInt( 10 ) );

            mode = new Mode(  );
            mode.setId( daoUtil.getInt( 1 ) );
            mode.setDescription( daoUtil.getString( 2 ) );
            mode.setPath( daoUtil.getString( 3 ) );
            mode.setOutputXslPropertyMethod( daoUtil.getString( 4 ) );
            mode.setOutputXslPropertyVersion( daoUtil.getString( 5 ) );
            mode.setOutputXslPropertyMediaType( daoUtil.getString( 6 ) );
            mode.setOutputXslPropertyEncoding( daoUtil.getString( 7 ) );
            mode.setOutputXslPropertyIndent( daoUtil.getString( 8 ) );
            mode.setOutputXslPropertyOmitXmlDeclaration( daoUtil.getString( 9 ) );
            mode.setOutputXslPropertyStandalone( daoUtil.getString( 10 ) );

    private void buildSQLFilter( StringBuilder sbSQL, AdminDashboardFilter filter )
    {
        List<String> listFilters = new ArrayList<String>(  );

        if ( filter.containsFilterOrder(  ) )
        {
            listFilters.add( SQL_QUERY_FILTER_ORDER );
        }

        if ( filter.containsFilterColumn(  ) )
        {
            listFilters.add( SQL_QUERY_FILTER_COLUMN );
        }

        if ( !listFilters.isEmpty(  ) )
        {
            sbSQL.append( SQL_QUERY_KEYWORD_WHERE );

            boolean bFirstFilter = true;

            for ( String strFilter : listFilters )
            {
                sbSQL.append( strFilter );

                if ( !bFirstFilter )
                {
                    sbSQL.append( SQL_QUERY_KEYWORD_AND );
                }
                else
                {
                    bFirstFilter = false;
                }
            }
        }
    }

    /**
     * Add daoUtil parameters
     * @param daoUtil daoUtil
     * @param nStartIndex start index
     * @param filter the filter to apply
     * @return end index
     */
    private int applySQLFilter( DAOUtil daoUtil, int nStartIndex, AdminDashboardFilter filter )

        daoUtil.setString( 1, strRoleKey );
        daoUtil.executeQuery(  );

        while ( daoUtil.next(  ) )
        {
            AdminUser user = new AdminUser(  );
            user.setUserId( daoUtil.getInt( 1 ) );
            user.setAccessCode( daoUtil.getString( 2 ) );
            user.setLastName( daoUtil.getString( 3 ) );
            user.setFirstName( daoUtil.getString( 4 ) );
            user.setEmail( daoUtil.getString( 5 ) );
            user.setStatus( daoUtil.getInt( 6 ) );
            user.setLocale( new Locale( daoUtil.getString( 7 ) ) );
            user.setAccessibilityMode( daoUtil.getBoolean( 8 ) );

            dashboard = AdminDashboardFactory.getDashboardComponent( strDashboardName );

            if ( dashboard == null )
            {
                return AdminMessageService.getMessageUrl( request, MESSAGE_DASHBOARD_NOT_FOUND, AdminMessage.TYPE_STOP );
            }
        }
        else
        {
            nOldOrder = dashboard.getOrder(  );
            nOldColumn = dashboard.getZone(  );
        }

        // set order and column
        String strOrder = request.getParameter( PARAMETER_DASHBOARD_ORDER );
        String strColumn = request.getParameter( PARAMETER_DASHBOARD_COLUMN );

        int nOrder = StringUtil.getIntValue( strOrder, -1 );
        int nColumn = StringUtil.getIntValue( strColumn, -1 );

        dashboard.setOrder( nOrder );
        dashboard.setZone( nColumn );

        _service.doMoveDashboard( dashboard, nOldColumn, nOldOrder, bCreate );

        return JSP_MANAGE_DASHBOARDS;
    }

        model.put( MARK_LIST_AVAILABLE_COLUMNS, getListAvailableColumns(  ) );
        model.put( MARK_MAP_COLUMN_ORDER_STATUS, _service.getOrderedColumnsStatus(  ) );

        HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_MANAGE_DASHBOARDS, user.getLocale(  ), model );

        return getAdminPage( template.getHtml(  ) );
    }

    /**
     * Reorders columns
     * @param request the request
     * @return url
     */
    public String doReorderColumn( HttpServletRequest request )
    {
        String strColumnName = request.getParameter( PARAMETER_COLUMN );

        if ( StringUtils.isBlank( strColumnName ) )
        {
            return AdminMessageService.getMessageUrl( request, Messages.MANDATORY_FIELDS, AdminMessage.TYPE_STOP );
        }

        int nColumn = 0;

        try
        {
            nColumn = Integer.parseInt( strColumnName );
        }
        catch ( NumberFormatException nfe )
        {
            AppLogService.error( "AdminDashboardJspBean.doReorderColumn : " + nfe.getMessage(  ), nfe );

    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getLabelFirst(  )
    {
        return I18nService.getLocalizedString( KEY_FIRST, _locale );
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public String getLabelPrevious(  )
    {
        return I18nService.getLocalizedString( KEY_PREVIOUS, _locale );
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public String getLabelNext(  )
    {
        return I18nService.getLocalizedString( KEY_NEXT, _locale );
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public String getLabelLast(  )
    {
        return I18nService.getLocalizedString( KEY_LAST, _locale );
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public String getLabelItemCount(  )
    {
        return I18nService.getLocalizedString( KEY_ITEM_COUNT, _locale );
    }

    /**
     * {@inheritDoc }
     */
    @Override
    public String getLabelItemCountPerPage(  )
    {
        return I18nService.getLocalizedString( KEY_ITEM_COUNT_PER_PAGE, _locale );
    }
}

{
    private Integer _nFilterColumn;
    private Integer _nFilterOrder;

    /**
     * Filter column
     * @return Filter column
     */
    public Integer getFilterColumn(  )
    {
        return _nFilterColumn;
    }

    /**
     * Filter column
     * @param nFilterColumn the Filter column
     */
    public void setFilterColumn( Integer nFilterColumn )
    {
        _nFilterColumn = nFilterColumn;
    }

    /**
     * Filter order
     * @return Filter order
     */
    public Integer getFilterOrder(  )
    {
        return _nFilterOrder;
    }

    /**
     * Filter order
     * @param nFilterOrder the Filter order
     */
    public void setFilterOrder( Integer nFilterOrder )
    {
        _nFilterOrder = nFilterOrder;
    }

    /**
     * true if {@link #getFilterOrder()} != null
     * @return <code>true</code> if {@link #getFilterOrder()} != null, <code>false</code> otherwise.
     */
    public boolean containsFilterOrder(  )
    {
        return _nFilterOrder != null;
    }

    /**
     * true if {@link #getFilterColumn()} != null
     * @return <code>true</code> if {@link #getFilterColumn()} != null, <code>false</code> otherwise
     */
    public boolean containsFilterColumn(  )
    {
        return _nFilterColumn != null;
    }

    /**
     *
     * {@inheritDoc}
     */
    @Override
    public String toString(  )
    {
        return this.getClass(  ).getName(  ) + "[column=" + this.getFilterColumn(  ) + ", order=" +
        this.getFilterOrder(  ) + "]";
    }
}

    public String doMoveUpAttributeField( HttpServletRequest request )
    {
        String strIdAttribute = request.getParameter( PARAMETER_ID_ATTRIBUTE );
        String strIdField = request.getParameter( PARAMETER_ID_FIELD );

        if ( StringUtils.isNotBlank( strIdField ) && StringUtils.isNumeric( strIdField ) &&
                StringUtils.isNotBlank( strIdAttribute ) && StringUtils.isNumeric( strIdAttribute ) )
        {
            int nIdAttribute = Integer.parseInt( strIdAttribute );
            int nIdField = Integer.parseInt( strIdField );

            IAttribute attribute = _attributeService.getAttributeWithFields( nIdAttribute, getLocale(  ) );
            List<AttributeField> listAttributeFields = attribute.getListAttributeFields(  );

            if ( listAttributeFields.size(  ) > 0 )
            {
                AttributeField previousField = null;

        if ( daoUtil.next(  ) )
        {
            xslExport = new XslExport(  );
            xslExport.setIdXslExport( daoUtil.getInt( 1 ) );
            xslExport.setTitle( daoUtil.getString( 2 ) );
            xslExport.setDescription( daoUtil.getString( 3 ) );
            xslExport.setExtension( daoUtil.getString( 4 ) );

            if ( daoUtil.getObject( 5 ) != null )
            {
                file = new File(  );
                file.setIdFile( daoUtil.getInt( 5 ) );
                xslExport.setFile( file );
            }

            xslExport.setPlugin( daoUtil.getString( 6 ) );