NoticeJspBean

/*
 * Copyright (c) 2002-2014, Mairie de Paris
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *  1. Redistributions of source code must retain the above copyright notice
 *     and the following disclaimer.
 *
 *  2. Redistributions in binary form must reproduce the above copyright notice
 *     and the following disclaimer in the documentation and/or other materials
 *     provided with the distribution.
 *
 *  3. Neither the name of 'Mairie de Paris' nor 'Lutece' nor the names of its
 *     contributors may be used to endorse or promote products derived from
 *     this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * License 1.0
 */
package fr.paris.lutece.plugins.formengine.web.notice;

import fr.paris.lutece.plugins.formengine.business.Notice;
import fr.paris.lutece.plugins.formengine.business.NoticeFilter;
import fr.paris.lutece.plugins.formengine.business.NoticeGroup;
import fr.paris.lutece.plugins.formengine.business.NoticeGroupFilter;
import fr.paris.lutece.plugins.formengine.business.NoticeGroupHome;
import fr.paris.lutece.plugins.formengine.business.NoticeHome;
import fr.paris.lutece.plugins.formengine.service.FormsRegistrationService;
import fr.paris.lutece.plugins.formengine.util.NoticeUtils;
import fr.paris.lutece.portal.business.mailinglist.MailingList;
import fr.paris.lutece.portal.business.mailinglist.MailingListHome;
import fr.paris.lutece.portal.service.admin.AdminUserService;
import fr.paris.lutece.portal.service.i18n.I18nService;
import fr.paris.lutece.portal.service.message.AdminMessage;
import fr.paris.lutece.portal.service.message.AdminMessageService;
import fr.paris.lutece.portal.service.plugin.Plugin;
import fr.paris.lutece.portal.service.template.AppTemplateService;
import fr.paris.lutece.portal.service.util.AppLogService;
import fr.paris.lutece.portal.service.util.AppPathService;
import fr.paris.lutece.portal.service.workgroup.AdminWorkgroupService;
import fr.paris.lutece.portal.web.admin.PluginAdminPageJspBean;
import fr.paris.lutece.util.ReferenceItem;
import fr.paris.lutece.util.ReferenceList;
import fr.paris.lutece.util.html.HtmlTemplate;
import fr.paris.lutece.util.html.Paginator;
import fr.paris.lutece.util.url.UrlItem;

import org.apache.commons.lang.StringUtils;

import java.sql.Timestamp;

import java.text.SimpleDateFormat;

import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;


/**
 * NoticeJspbean
 *
 */
public class NoticeJspBean extends PluginAdminPageJspBean
{
    // RIGHT
    public static final String RIGHT_NOTICE_MANAGEMENT = "NOTICE_MANAGEMENT";

    // MARKERS
    private static final String MARK_WEBAPP_URL = "webapp_url";
    private static final String MARK_LOCALE = "locale";
    private static final String MARK_LIST_STATUT = "notice_statut";
    private static final String MARK_LIST_USER_GROUP = "notice_user_group";
    private static final String MARK_PAGINATOR = "paginator";
    private static final String MARK_NB_ITEMS_PER_PAGE = "nb_items_per_page";
    private static final String MARK_NOTICE_LIST = "notice_list";
    private static final String MARK_NOTICE_GROUP_LIST = "notice_group_list";
    private static final String MARK_WORKGROUP_LIST = "user_workgroup_list";
    private static final String MARK_MAILING_LIST = "mailing_list";
    private static final String MARK_FORM = "form_list";
    private static final String MARK_NOTICE = "notice";
    private static final String MARK_NOTICE_GROUP = "notice_group";
    private static final String MARK_NOTICE_GROUP_ID = "notice_group_id";
    private static final String MARK_DATE_DU_JOUR = "date_du_jour";
    private static final String MARK_USER_WORKGROUP_SELECTED = "user_workgroup_selected";
    private static final String MARK_ACTIVE_SELECTED = "active_selected";
    private static final String MARK_FORM_SELECTED = "form_selected";
    private static final String MARK_FORM_MAP = "form_map";

    // PARAMETERS
    private static final String PARAMETER_CANCEL = "cancel";
    private static final String PARAMETER_ACTIVE = "active";
    private static final String PARAMETER_WORKGROUP = "workgroup";
    private static final String PARAMETER_TITLE = "title";
    private static final String PARAMETER_MESSAGE = "message";
    private static final String PARAMETER_DATE_DEBUT = "date_begin_disponibility";
    private static final String PARAMETER_DATE_FIN = "date_end_disponibility";
    private static final String PARAMETER_ID_MAILINIG_LIST = "mailing";
    private static final String PARAMETER_FORM = "form";
    private static final String PARAMETER_ID_NOTICE = "id_notice";
    private static final String PARAMETER_ID_NOTICE_GROUP = "id_notice_group";
    private static final String PARAMETER_ORDER = "order";

    // PROPERTIES
    private static final String PROPERTY_CREATE_NOTICE_PAGE_TITLE = "formengine.adminFeature.notice_create.name";
    private static final String PROPERTY_CREATE_NOTICE_GROUP_PAGE_TITLE = "formengine.adminFeature.notice_group_create.name";
    private static final String PROPERTY_COPY_NOTICE_TITLE = "formengine.adminFeature.notice_copy.name";
    private static final String PROPERTY_COPY_NOTICE_GROUP_TITLE = "formengine.adminFeature.notice_copy_notice_group.name";
    private static final String PROPERTY_MODIFY_NOTICE_TITLE = "formengine.notice.label.modify_notice.title";
    private static final String PROPERTY_MODIFY_NOTICE_GROUP_TITLE = "formengine.adminFeature.notice_group_modify.name";
    private static final String PROPERTY_MANAGE_NOTICE_GROUP_TITLE = "formengine.notice_group.label.manage.title";

    // JSP
    private static final String JSP_MANAGE_NOTICE_GROUP = "jsp/admin/plugins/formengine/ManageNoticeGroup.jsp";
    private static final String JSP_MANAGE_NOTICE = "jsp/admin/plugins/formengine/ManageNotice.jsp";
    private static final String JSP_DO_REMOVE_NOTICE = "jsp/admin/plugins/formengine/DoRemoveNotice.jsp";
    private static final String JSP_DO_REMOVE_NOTICE_GROUP = "jsp/admin/plugins/formengine/DoRemoveNoticeGroup.jsp";

    // TEMPLATES
    private static final String TEMPLATE_FORMENGINE_NOTICE = "/admin/plugins/formengine/notice/manage_formengine_notice.html";
    private static final String TEMPLATE_FORMENGINE_CREATE_NOTICE = "/admin/plugins/formengine/notice/create_notice.html";
    private static final String TEMPLATE_MODIFY_NOTICE = "/admin/plugins/formengine/notice/modify_notice.html";
    private static final String TEMPLATE_MANAGE_NOTICE_GROUP = "/admin/plugins/formengine/notice/manage_formengine_notice_group.html";
    private static final String TEMPLATE_CREATE_NOTICE_GROUP = "/admin/plugins/formengine/notice/create_notice_group.html";
    private static final String TEMPLATE_MODIFY_NOTICE_GROUP = "/admin/plugins/formengine/notice/modify_notice_group.html";

    // MESSAGES
    private static final String MESSAGE_NOTICE_MANDATORY = "formengine.notice.message.mandatory.field";
    private static final String MESSAGE_FIELD_TITLE = "formengine.notice.message.title";
    private static final String MESSAGE_FIELD_MESSAGE = "formengine.notice.message.message";
    private static final String MESSAGE_ERROR_DATE = "formengine.notice.message.error_date";
    private static final String MESSAGE_ERROR_NOTICE_GROUP = "formengine.notice.message.noticegroup";
    private static final String MESSAGE_CONFIRM_REMOVE_NOTICE = "formengine.notice.message.remove_notice";
    private static final String MESSAGE_CONFIRM_REMOVE_NOTICE_GROUP = "formengine.notice_group.message.remove_notice_group";
    private static final String MESSAGE_ALL = "formengine.notice.message.all";
    private static final String MESSAGE_ACTIVATED = "formengine.notice.message.activated";
    private static final String MESSAGE_NOT_ACTIVATED = "formengine.notice.message.notActivated";
    private static final String MESSAGE_NONE = "formengine.notice.message.none";
    private static final String MESSAGE_FIELD_FORM = "formengine.notice.message.form";

    // CONSTANTS
    private static final String CONSTANT_NO_FORM = "-1";

    // ATTRIBUTES
    private static final int DEFAULT_ITEMS_PER_PAGE = 10;
    private int _nItemsPerPage;
    private String _strCurrentPageIndex;
    private int _nIdActive = -1;
    private String _strWorkGroup = AdminWorkgroupService.ALL_GROUPS;
    private int _nIdNoticeGroup;
    private String _strForm = NoticeGroupFilter.ALL_STRING;

    /**
     * Return the reference list of statut
     * @return the referenclist of statut
     */
    private ReferenceList initRefListStatut(  )
    {
        ReferenceList refListStatut = new ReferenceList(  );

        refListStatut.addItem( -1, I18nService.getLocalizedString( MESSAGE_ALL, getLocale(  ) ) );
        refListStatut.addItem( 0, I18nService.getLocalizedString( MESSAGE_NOT_ACTIVATED, getLocale(  ) ) );
        refListStatut.addItem( 1, I18nService.getLocalizedString( MESSAGE_ACTIVATED, getLocale(  ) ) );

        return refListStatut;
    }

    /**
     * Return the reference list of user group
     * @return the referenclist of user group
     */
    private ReferenceList initRefListUserGroup(  )
    {
        return AdminWorkgroupService.getUserWorkgroups( getUser(  ), getLocale(  ) );
    }

    /**
     * Return the reference list of mailing list
     * @return the referenclist of mailing list
     */
    private ReferenceList initRefListMailingList(  )
    {
        ReferenceList refListMailingList = new ReferenceList(  );
        Collection<MailingList> colMailingList = MailingListHome.findAll(  );
        int count = 0;
        refListMailingList.addItem( -1, I18nService.getLocalizedString( MESSAGE_NONE, getLocale(  ) ) );

        for ( MailingList mailingList : colMailingList )
        {
            refListMailingList.addItem( count, mailingList.getName(  ) );
            count++;
        }

        return refListMailingList;
    }

    /**
     * Gets form list
     * @return the form list
     */
    private ReferenceList initRefListFormsList(  )
    {
        ReferenceList refListForms = FormsRegistrationService.getListForm(  );
        ReferenceItem refItem = new ReferenceItem(  );
        refItem.setCode( NoticeGroupFilter.ALL_STRING );
        refItem.setName( I18nService.getLocalizedString( MESSAGE_ALL, getLocale(  ) ) );
        refListForms.add( 0, refItem );

        return refListForms;
    }

    /**
     * Return the reference list of rss feeds
     * @return the referenclist of rss feeds
     */

    /*private ReferenceList initRefListRssFeeds(  )
    {
        ReferenceList refListRss = new ReferenceList(  );

        if ( RssLibraryService.getInstance(  ).isAvailable(  ) )
        {
            refListRss = RssLibraryService.getInstance(  ).getRefListRssFeed(  );
        }

        refListRss.addItem( -1, CONSTANTE_RSS_LIST_NONE );

        return refListRss;
    }*/

    /**
     * Manages notice group
     * @param request the request
     * @return html code
     */
    public String getManageNoticeGroup( HttpServletRequest request )
    {
        setPageTitleProperty( PROPERTY_MANAGE_NOTICE_GROUP_TITLE );

        String strFilterForm = request.getParameter( PARAMETER_FORM );
        String strFilterWorkgroup = request.getParameter( PARAMETER_WORKGROUP );
        String strFilterStatus = request.getParameter( PARAMETER_ACTIVE );

        if ( StringUtils.isNotBlank( strFilterForm ) )
        {
            _strForm = strFilterForm;
        }

        if ( StringUtils.isNotBlank( strFilterWorkgroup ) )
        {
            _strWorkGroup = strFilterWorkgroup;
        }

        if ( StringUtils.isNotBlank( strFilterStatus ) )
        {
            _nIdActive = NoticeUtils.convertStringToInt( strFilterStatus );
        }

        NoticeGroupFilter filter = new NoticeGroupFilter(  );
        filter.setForm( _strForm );
        filter.setIsEnbled( _nIdActive );
        filter.setWorkGroup( _strWorkGroup );

        _strCurrentPageIndex = Paginator.getPageIndex( request, Paginator.PARAMETER_PAGE_INDEX, _strCurrentPageIndex );
        _nItemsPerPage = Paginator.getItemsPerPage( request, Paginator.PARAMETER_ITEMS_PER_PAGE, _nItemsPerPage,
                DEFAULT_ITEMS_PER_PAGE );

        List<NoticeGroup> listNoticeGroup = NoticeGroupHome.findByFilter( filter, getPlugin(  ) );

        listNoticeGroup = (List<NoticeGroup>) AdminWorkgroupService.getAuthorizedCollection( listNoticeGroup,
                getUser(  ) );

        Paginator<NoticeGroup> paginator = new Paginator<NoticeGroup>( listNoticeGroup, _nItemsPerPage,
                getJspManageNoticeGroup( request ), Paginator.PARAMETER_PAGE_INDEX, _strCurrentPageIndex );

        Map<String, Object> model = new HashMap<String, Object>(  );

        model.put( MARK_LIST_STATUT, initRefListStatut(  ) );
        model.put( MARK_ACTIVE_SELECTED, _nIdActive );
        model.put( MARK_LIST_USER_GROUP, initRefListUserGroup(  ) );
        model.put( MARK_USER_WORKGROUP_SELECTED, _strWorkGroup );
        model.put( MARK_PAGINATOR, paginator );
        model.put( MARK_FORM, initRefListFormsList(  ) );
        model.put( MARK_FORM_SELECTED, _strForm );
        model.put( MARK_NOTICE_GROUP_LIST, paginator.getPageItems(  ) );
        model.put( MARK_FORM_MAP, FormsRegistrationService.getMapForm(  ) );
        model.put( MARK_NB_ITEMS_PER_PAGE, "" + _nItemsPerPage );

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

        return getAdminPage( template.getHtml(  ) );
    }

    /**
     * Show create notice group form
     * @param request the request
     * @return html code
     */
    public String getCreateNoticeGroup( HttpServletRequest request )
    {
        Map<String, Object> model = new HashMap<String, Object>(  );
        setPageTitleProperty( PROPERTY_CREATE_NOTICE_GROUP_PAGE_TITLE );

        model.put( MARK_WEBAPP_URL, AppPathService.getBaseUrl( request ) );
        model.put( MARK_LOCALE, AdminUserService.getLocale( request ).getLanguage(  ) );
        model.put( MARK_MAILING_LIST, initRefListMailingList(  ) );
        model.put( MARK_WORKGROUP_LIST, initRefListUserGroup(  ) );
        model.put( MARK_FORM, FormsRegistrationService.getListForm(  ) );

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

        return getAdminPage( template.getHtml(  ) );
    }

    /**
     * Gets modify notice group html code
     * @param request the request
     * @return html code
     */
    public String getModifyNoticeGroup( HttpServletRequest request )
    {
        String strIdNoticeGroup = request.getParameter( PARAMETER_ID_NOTICE_GROUP );

        if ( StringUtils.isBlank( strIdNoticeGroup ) )
        {
            return getNoticeManagement( request );
        }

        int nIdNotice = NoticeUtils.convertStringToInt( strIdNoticeGroup );

        if ( nIdNotice == -1 )
        {
            return getNoticeManagement( request );
        }

        NoticeGroup noticeGroup = NoticeGroupHome.findByPrimaryKey( nIdNotice, getPlugin(  ) );

        if ( ( noticeGroup == null ) )
        {
            return getNoticeManagement( request );
        }

        Locale locale = getLocale(  );

        Map<String, Object> model = new HashMap<String, Object>(  );

        model.put( MARK_WORKGROUP_LIST, initRefListUserGroup(  ) );
        model.put( MARK_MAILING_LIST, initRefListMailingList(  ) );
        model.put( MARK_NOTICE_GROUP, noticeGroup );
        model.put( MARK_WEBAPP_URL, AppPathService.getBaseUrl( request ) );
        model.put( MARK_LOCALE, getLocale(  ) );
        model.put( MARK_FORM, FormsRegistrationService.getListForm(  ) );

        setPageTitleProperty( PROPERTY_MODIFY_NOTICE_GROUP_TITLE );

        HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_MODIFY_NOTICE_GROUP, locale, model );

        return getAdminPage( template.getHtml(  ) );
    }

    /**
     * Gets fields from request
     * @param noticeGroup the notice group
     * @param request the request
     * @return error message url if any, <code>null</code> otherwise.
     */
    private String getFields( NoticeGroup noticeGroup, HttpServletRequest request )
    {
        String strForm = request.getParameter( PARAMETER_FORM );
        String strTitle = request.getParameter( PARAMETER_TITLE );
        String strWorkgroupKey = request.getParameter( PARAMETER_WORKGROUP );

        if ( StringUtils.isBlank( strForm ) || CONSTANT_NO_FORM.equals( strForm ) )
        {
            return buildUrlMessageMissingField( I18nService.getLocalizedString( MESSAGE_FIELD_FORM, getLocale(  ) ),
                request );
        }

        if ( StringUtils.isBlank( strTitle ) )
        {
            return buildUrlMessageMissingField( I18nService.getLocalizedString( MESSAGE_FIELD_TITLE, getLocale(  ) ),
                request );
        }

        noticeGroup.setForm( strForm );
        noticeGroup.setTitle( strTitle );
        noticeGroup.setWorkgroupKey( strWorkgroupKey );

        return null;
    }

    /**
     * Builds missing field message
     * @param strField the I18n field key
     * @param request the request
     * @return url
     */
    private String buildUrlMessageMissingField( String strField, HttpServletRequest request )
    {
        Object[] messageArgs = { strField, };

        return AdminMessageService.getMessageUrl( request, MESSAGE_NOTICE_MANDATORY, messageArgs, AdminMessage.TYPE_STOP );
    }

    /**
     * Creates the notice group
     * @param request the reques
     * @return url
     */
    public String doCreateNoticeGroup( HttpServletRequest request )
    {
        if ( request.getParameter( PARAMETER_CANCEL ) != null )
        {
            return getJspManageNoticeGroup( request );
        }

        NoticeGroup noticeGroup = new NoticeGroup(  );
        String strError = getFields( noticeGroup, request );

        if ( strError != null )
        {
            return strError;
        }

        NoticeGroupHome.create( noticeGroup, getPlugin(  ) );

        return getHomeUrl( request );
    }

    /**
     * Modifies the notice group
     * @param request the request
     * @return url
     */
    public String doModifyNoticeGroup( HttpServletRequest request )
    {
        if ( request.getParameter( PARAMETER_CANCEL ) != null )
        {
            return getJspManageNoticeGroup( request );
        }

        String strIdNoticeGroup = request.getParameter( PARAMETER_ID_NOTICE_GROUP );

        if ( StringUtils.isBlank( strIdNoticeGroup ) )
        {
            return getJspManageNoticeGroup( request );
        }

        int nIdNoticeGroup = NoticeUtils.convertStringToInt( strIdNoticeGroup );

        if ( nIdNoticeGroup == -1 )
        {
            return getJspManageNoticeGroup( request );
        }

        NoticeGroup noticeGroup = NoticeGroupHome.findByPrimaryKey( nIdNoticeGroup, getPlugin(  ) );
        String strError = getFields( noticeGroup, request );

        if ( strError != null )
        {
            return strError;
        }

        NoticeGroupHome.update( noticeGroup, getPlugin(  ) );

        return getHomeUrl( request );
    }

    /**
     * Gets confirme message before removing the notice group
     * @param request the request
     * @return message url
     */
    public String getConfirmRemoveNoticeGroup( HttpServletRequest request )
    {
        UrlItem urlItem = new UrlItem( AppPathService.getBaseUrl( request ) + JSP_DO_REMOVE_NOTICE_GROUP );

        Map<Object, Object> requestParameters = new HashMap<Object, Object>(  );
        requestParameters.put( PARAMETER_ID_NOTICE_GROUP, request.getParameter( PARAMETER_ID_NOTICE_GROUP ) );

        return AdminMessageService.getMessageUrl( request, MESSAGE_CONFIRM_REMOVE_NOTICE_GROUP, urlItem.getUrl(  ),
            AdminMessage.TYPE_CONFIRMATION, requestParameters );
    }

    /**
     * Actually removes the notice group
     * @param request the request
     * @return manage url
     */
    public String doRemoveNoticeGroup( HttpServletRequest request )
    {
        String strIdNoticeGroup = request.getParameter( PARAMETER_ID_NOTICE_GROUP );

        if ( StringUtils.isBlank( strIdNoticeGroup ) )
        {
            return getJspManageNoticeGroup( request );
        }

        int nIdNoticeGroup = NoticeUtils.convertStringToInt( strIdNoticeGroup );

        if ( nIdNoticeGroup == -1 )
        {
            return getJspManageNoticeGroup( request );
        }

        NoticeGroupHome.remove( nIdNoticeGroup, getPlugin(  ) );

        return getHomeUrl( request );
    }

    /**
     * Gets the notice management page
     * @param request The HTTP request
     * @return The notice management page
     */
    public String getNoticeManagement( HttpServletRequest request )
    {
        List<Notice> listNotice;
        String strWorkGroup = request.getParameter( PARAMETER_WORKGROUP );
        String strActive = request.getParameter( PARAMETER_ACTIVE );
        String strIdNoticeGroup = request.getParameter( PARAMETER_ID_NOTICE_GROUP );

        _strCurrentPageIndex = Paginator.getPageIndex( request, Paginator.PARAMETER_PAGE_INDEX, _strCurrentPageIndex );
        _nItemsPerPage = Paginator.getItemsPerPage( request, Paginator.PARAMETER_ITEMS_PER_PAGE, _nItemsPerPage,
                DEFAULT_ITEMS_PER_PAGE );

        if ( ( strActive != null ) && !strActive.equals( NoticeUtils.EMPTY_STRING ) )
        {
            _nIdActive = NoticeUtils.convertStringToInt( strActive );
        }

        if ( ( strWorkGroup != null ) && !strWorkGroup.equals( NoticeUtils.EMPTY_STRING ) )
        {
            _strWorkGroup = strWorkGroup;
        }

        int nIdNoticeGroup = NoticeUtils.convertStringToInt( strIdNoticeGroup );

        if ( nIdNoticeGroup != -1 )
        {
            _nIdNoticeGroup = nIdNoticeGroup;
        }

        //String format = "dd/MM/yyyy";

        //java.text.SimpleDateFormat formater = new java.text.SimpleDateFormat( format );
        //java.util.Date date = new java.util.Date(  );
        NoticeFilter filter = new NoticeFilter(  );
        filter.setIsEnabled( _nIdActive );
        filter.setWorkGroup( _strWorkGroup );
        filter.setIdNoticeGroup( _nIdNoticeGroup );

        listNotice = NoticeHome.getNoticeList( filter, getPlugin(  ) );
        listNotice = (List<Notice>) AdminWorkgroupService.getAuthorizedCollection( listNotice, getUser(  ) );

        String strURL = getJspManageNotice( request );

        /*if ( strAscSort != null )
        {
            strURL += ( "&" + Parameters.SORTED_ASC + "=" + strAscSort );
        }*/
        Paginator<Notice> paginator = new Paginator<Notice>( listNotice, _nItemsPerPage, strURL,
                Paginator.PARAMETER_PAGE_INDEX, _strCurrentPageIndex );

        Map<String, Object> model = new HashMap<String, Object>(  );

        model.put( MARK_LIST_STATUT, initRefListStatut(  ) );
        model.put( MARK_ACTIVE_SELECTED, _nIdActive );
        model.put( MARK_LIST_USER_GROUP, initRefListUserGroup(  ) );
        model.put( MARK_USER_WORKGROUP_SELECTED, _strWorkGroup );
        model.put( MARK_PAGINATOR, paginator );
        model.put( MARK_NB_ITEMS_PER_PAGE, "" + _nItemsPerPage );
        model.put( MARK_NOTICE_LIST, paginator.getPageItems(  ) );
        model.put( MARK_DATE_DU_JOUR, "" + NoticeUtils.getDate( NoticeUtils.getCurrentDate(  ), null ) );

        //setPageTitleProperty( PROPERTY_MANAGE_NOTICE_PAGE_TITLE );
        setPageTitleProperty( NoticeUtils.EMPTY_STRING );

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

        return getAdminPage( template.getHtml(  ) );
    }

    /**
     * Changes notice order
     * @param request the request
     * @return the url
     */
    public String doChangeNoticeOrder( HttpServletRequest request )
    {
        String strOrder = request.getParameter( PARAMETER_ORDER );
        String strIdNotice = request.getParameter( PARAMETER_ID_NOTICE );

        if ( StringUtils.isBlank( strOrder ) || StringUtils.isBlank( strIdNotice ) )
        {
            return getJspManageNotice( request );
        }

        int nIdNotice = NoticeUtils.convertStringToInt( strIdNotice );
        int nOrder = NoticeUtils.convertStringToInt( strOrder );

        if ( ( nIdNotice == -1 ) || ( nOrder == -1 ) )
        {
            return getJspManageNotice( request );
        }

        Notice notice = NoticeHome.findByPrimaryKey( nIdNotice, getPlugin(  ) );

        if ( notice == null )
        {
            return getJspManageNotice( request );
        }

        // save old order to reorder list
        int nOldOrder = notice.getOrder(  );

        // get noticegroup notices
        NoticeFilter filter = new NoticeFilter(  );
        filter.setIdNoticeGroup( notice.getIdNoticeGroup(  ) );

        List<Notice> listNotices = NoticeHome.getNoticeList( filter, getPlugin(  ) );

        if ( nOrder < nOldOrder )
        {
            for ( Notice currentNotice : listNotices )
            {
                if ( !notice.equals( currentNotice ) )
                {
                    int nCurrentOrder = currentNotice.getOrder(  );

                    if ( ( nCurrentOrder >= nOrder ) && ( nCurrentOrder < nOldOrder ) )
                    {
                        currentNotice.setOrder( nCurrentOrder + 1 );
                        NoticeHome.update( currentNotice, getPlugin(  ) );
                    }
                }
            }
        }
        else if ( nOrder > nOldOrder )
        {
            for ( Notice currentNotice : listNotices )
            {
                if ( !notice.equals( currentNotice ) )
                {
                    int nCurrentOrder = currentNotice.getOrder(  );

                    if ( ( nCurrentOrder <= nOrder ) && ( nCurrentOrder > nOldOrder ) )
                    {
                        currentNotice.setOrder( nCurrentOrder - 1 );
                        NoticeHome.update( currentNotice, getPlugin(  ) );
                    }
                }
            }
        }

        notice.setOrder( nOrder );
        NoticeHome.update( notice, getPlugin(  ) );

        return getJspManageNotice( request );
    }

    /**
     * Gets the create notice page
     * @param request The HTTP request
     * @return The create notice page
     */
    public String getCreateNotice( HttpServletRequest request )
    {
        Map<String, Object> model = new HashMap<String, Object>(  );
        setPageTitleProperty( PROPERTY_CREATE_NOTICE_PAGE_TITLE );

        model.put( MARK_WEBAPP_URL, AppPathService.getBaseUrl( request ) );
        model.put( MARK_LOCALE, AdminUserService.getLocale( request ).getLanguage(  ) );
        model.put( MARK_MAILING_LIST, initRefListMailingList(  ) );
        model.put( MARK_WORKGROUP_LIST, initRefListUserGroup(  ) );
        /*model.put( MARK_RSS_AVAILABLE, RssLibraryService.getInstance(  ).isAvailable(  ) );
        model.put( MARK_RSS_LIST, initRefListRssFeeds(  ) );*/
        model.put( MARK_FORM, FormsRegistrationService.getListForm(  ) );
        model.put( MARK_NOTICE_GROUP_ID, _nIdNoticeGroup );

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

        return getAdminPage( template.getHtml(  ) );
    }

    /**
    * Perform the notice creation
    * @param request The HTTP request
    * @return The URL to go after performing the action
    */
    public String doCreateNotice( HttpServletRequest request )
    {
        if ( ( request.getParameter( PARAMETER_CANCEL ) == null ) )
        {
            Notice notice = new Notice(  );
            String strError = getNoticeData( request, notice );

            if ( strError != null )
            {
                return strError;
            }

            notice.setOrder( NoticeHome.findMaxOrderForNoticeGroup( notice.getIdNoticeGroup(  ), getPlugin(  ) ) + 1 );

            NoticeHome.create( notice, getPlugin(  ) );
        }

        return getJspManageNotice( request );
    }

    /**
     * Gets the notice modification page
     * @param request The HTTP request
     * @return The  notice modification page
     */
    public String getModifyNotice( HttpServletRequest request )
    {
        Plugin plugin = getPlugin(  );
        String strIdNotice = request.getParameter( PARAMETER_ID_NOTICE );
        int nIdNotice = -1;
        Notice notice;

        if ( ( strIdNotice != null ) && !strIdNotice.equals( NoticeUtils.EMPTY_STRING ) )
        {
            try
            {
                nIdNotice = Integer.parseInt( strIdNotice );
            }
            catch ( NumberFormatException ne )
            {
                AppLogService.error( ne );

                return getNoticeManagement( request );
            }
        }

        notice = NoticeHome.findByPrimaryKey( nIdNotice, plugin );

        if ( ( notice == null ) )
        {
            return getNoticeManagement( request );
        }

        Locale locale = getLocale(  );

        Map<String, Object> model = new HashMap<String, Object>(  );

        model.put( MARK_WORKGROUP_LIST, initRefListUserGroup(  ) );
        model.put( MARK_MAILING_LIST, initRefListMailingList(  ) );
        /*model.put( MARK_RSS_LIST, initRefListRssFeeds(  ) );
        model.put( MARK_RSS_AVAILABLE, RssLibraryService.getInstance(  ).isAvailable(  ) );*/
        model.put( MARK_NOTICE, notice );
        model.put( MARK_WEBAPP_URL, AppPathService.getBaseUrl( request ) );
        model.put( MARK_LOCALE, AdminUserService.getLocale( request ).getLanguage(  ) );
        model.put( MARK_FORM, FormsRegistrationService.getListForm(  ) );

        setPageTitleProperty( PROPERTY_MODIFY_NOTICE_TITLE );

        HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_MODIFY_NOTICE, locale, model );

        return getAdminPage( template.getHtml(  ) );
    }

    /**
     * Perform the notice modification
     * @param request The HTTP request
     * @return The URL to go after performing the action
     */
    public String doModifyNotice( HttpServletRequest request )
    {
        if ( request.getParameter( PARAMETER_CANCEL ) == null )
        {
            Plugin plugin = getPlugin(  );
            String strIdNotice = request.getParameter( PARAMETER_ID_NOTICE );
            int nIdNotice = -1;
            Notice notice;

            if ( ( strIdNotice != null ) && !strIdNotice.equals( NoticeUtils.EMPTY_STRING ) )
            {
                try
                {
                    nIdNotice = Integer.parseInt( strIdNotice );
                }
                catch ( NumberFormatException ne )
                {
                    AppLogService.error( ne );
                }
            }

            if ( nIdNotice != -1 )
            {
                notice = NoticeHome.findByPrimaryKey( nIdNotice, plugin );

                if ( ( notice == null ) )
                {
                    return getJspManageNotice( request );
                }

                String strError = getNoticeData( request, notice );

                if ( strError != null )
                {
                    return strError;
                }

                notice.setIdNotice( nIdNotice );

                NoticeHome.update( notice, getPlugin(  ) );

                /*if ( request.getParameter( PARAMETER_APPLY ) != null )
                {
                    return getJspModifyNotice( request, nIdNotice );
                }*/
            }
        }

        return getJspManageNotice( request );
    }

    /**
     * Copy the notice group
     * @param request The HTTP request
     * @return The forward URL
     */
    public String doCopyNoticeGroup( HttpServletRequest request )
    {
        String strIdNotice = request.getParameter( PARAMETER_ID_NOTICE_GROUP );

        if ( StringUtils.isBlank( strIdNotice ) )
        {
            return getHomeUrl( request );
        }

        int nIdNoticeGroup = NoticeUtils.convertStringToInt( strIdNotice );

        if ( nIdNoticeGroup != -1 )
        {
            NoticeGroup noticeGroup = NoticeGroupHome.findByPrimaryKey( nIdNoticeGroup, getPlugin(  ) );

            Object[] tabFormTileCopy = { noticeGroup.getTitle(  ) };
            String strTitleCopyForm = I18nService.getLocalizedString( PROPERTY_COPY_NOTICE_GROUP_TITLE,
                    tabFormTileCopy, getLocale(  ) );

            if ( strTitleCopyForm != null )
            {
                noticeGroup.setTitle( strTitleCopyForm );
            }

            NoticeGroupHome.create( noticeGroup, getPlugin(  ) );
        }

        return getHomeUrl( request );
    }

    /**
     * copy the notice whose key is specified in the Http request
     * @param request The HTTP request
     * @return The URL to go after performing the action
     */
    public String doCopyNotice( HttpServletRequest request )
    {
        Plugin plugin = getPlugin(  );
        Notice notice;
        String strIdNotice = request.getParameter( PARAMETER_ID_NOTICE );
        int nIdNotice = -1;

        if ( request.getParameter( PARAMETER_ID_NOTICE ) == null )
        {
            return getHomeUrl( request );
        }

        try
        {
            nIdNotice = Integer.parseInt( strIdNotice );
        }
        catch ( NumberFormatException ne )
        {
            AppLogService.error( ne );
        }

        if ( ( nIdNotice != -1 ) )
        {
            notice = NoticeHome.findByPrimaryKey( nIdNotice, plugin );

            Object[] tabFormTileCopy = { notice.getTitle(  ) };
            String strTitleCopyForm = I18nService.getLocalizedString( PROPERTY_COPY_NOTICE_TITLE, tabFormTileCopy,
                    getLocale(  ) );

            if ( strTitleCopyForm != null )
            {
                notice.setTitle( strTitleCopyForm );
            }

            notice.setOrder( NoticeHome.findMaxOrderForNoticeGroup( notice.getIdNoticeGroup(  ), getPlugin(  ) ) + 1 );

            NoticeHome.create( notice, plugin );
        }

        return getJspManageNotice( request );
    }

    /**
     * Perform disable notice
     * @param request The HTTP request
     * @return The URL to go after performing the action
     */
    public String doDisableNotice( HttpServletRequest request )
    {
        Notice notice;
        Plugin plugin = getPlugin(  );
        String strIdNotice = request.getParameter( PARAMETER_ID_NOTICE );
        int nIdNotice = -1;

        if ( ( strIdNotice == null ) )
        {
            return getHomeUrl( request );
        }

        try
        {
            nIdNotice = Integer.parseInt( strIdNotice );
            notice = NoticeHome.findByPrimaryKey( nIdNotice, plugin );
        }
        catch ( NumberFormatException ne )
        {
            AppLogService.error( ne );

            return getHomeUrl( request );
        }

        if ( nIdNotice != -1 )
        {
            notice.setEnabled( false );
            NoticeHome.update( notice, getPlugin(  ) );
        }

        return getJspManageNotice( request );
    }

    /**
     * Enables the notice group
     * @param request the request
     * @return home url
     */
    public String doEnableNoticeGroup( HttpServletRequest request )
    {
        String strIdNoticeGroup = request.getParameter( PARAMETER_ID_NOTICE_GROUP );

        if ( StringUtils.isBlank( strIdNoticeGroup ) )
        {
            return getHomeUrl( request );
        }

        int nIdNoticeGroup = NoticeUtils.convertStringToInt( strIdNoticeGroup );

        if ( nIdNoticeGroup == -1 )
        {
            return getHomeUrl( request );
        }

        NoticeGroup noticeGroup = NoticeGroupHome.findByPrimaryKey( nIdNoticeGroup, getPlugin(  ) );

        if ( noticeGroup == null )
        {
            AppLogService.error( "Formengine : No notice group found for id=" + nIdNoticeGroup );

            return getHomeUrl( request );
        }

        if ( !noticeGroup.isEnabled(  ) )
        {
            noticeGroup.setEnabled( true );
            NoticeGroupHome.update( noticeGroup, getPlugin(  ) );
        }

        return getHomeUrl( request );
    }

    /**
     * Disables the notice group
     * @param request the request
     * @return home url
      */
     public String doDisableNoticeGroup( HttpServletRequest request )
     {
         String strIdNoticeGroup = request.getParameter( PARAMETER_ID_NOTICE_GROUP );

         if ( StringUtils.isBlank( strIdNoticeGroup ) )
         {
             return getHomeUrl( request );
         }

         int nIdNoticeGroup = NoticeUtils.convertStringToInt( strIdNoticeGroup );

         if ( nIdNoticeGroup == -1 )
         {
             return getHomeUrl( request );
         }

         NoticeGroup noticeGroup = NoticeGroupHome.findByPrimaryKey( nIdNoticeGroup, getPlugin(  ) );

         if ( noticeGroup == null )
         {
             AppLogService.error( "Formengine : No notice group found for id=" + nIdNoticeGroup );

             return getHomeUrl( request );
         }

         if ( noticeGroup.isEnabled(  ) )
         {
             noticeGroup.setEnabled( false );
             NoticeGroupHome.update( noticeGroup, getPlugin(  ) );
         }

         return getHomeUrl( request );
     }

     /**
      * Perform enable notice
      * @param request The HTTP request
      * @return The URL to go after performing the action
      */
     public String doEnableNotice( HttpServletRequest request )
     {
         Notice notice;
         Plugin plugin = getPlugin(  );
         String strIdNotice = request.getParameter( PARAMETER_ID_NOTICE );
         int nIdNotice = -1;

         if ( ( strIdNotice == null ) )
         {
             return getHomeUrl( request );
         }

         try
         {
             nIdNotice = Integer.parseInt( strIdNotice );
             notice = NoticeHome.findByPrimaryKey( nIdNotice, plugin );
         }
         catch ( NumberFormatException ne )
         {
             AppLogService.error( ne );

             return getHomeUrl( request );
         }

         if ( nIdNotice != -1 )
         {
             /*if ( ( notice.getDateEndDisponibility(  ) != null ) &&
                     notice.getDateEndDisponibility(  ).before( NoticeUtils.getCurrentDate(  ) ) )
             {
                 return AdminMessageService.getMessageUrl( request,
                     MESSAGE_CANT_ENABLE_FORM_DATE_END_DISPONIBILITY_BEFORE_CURRENT_DATE, AdminMessage.TYPE_STOP );
             }*/
             notice.setEnabled( true );
             NoticeHome.update( notice, getPlugin(  ) );
         }

         return getJspManageNotice( request );
     }

     /**
      * Gets the notice data
      * @param request The HTTP request
      * @param notice Notice
      * @return The notice data
      */
     private String getNoticeData( HttpServletRequest request, Notice notice )
     {
         String strTitle = request.getParameter( PARAMETER_TITLE );
         String strMessage = request.getParameter( PARAMETER_MESSAGE );
         String strWorkgroup = request.getParameter( PARAMETER_WORKGROUP );
         String strMailingList = request.getParameter( PARAMETER_ID_MAILINIG_LIST );
         String strDateDebut = request.getParameter( PARAMETER_DATE_DEBUT );
         String strDateFin = request.getParameter( PARAMETER_DATE_FIN );
         String strIdNoticeGroup = request.getParameter( PARAMETER_ID_NOTICE_GROUP );

         // String strOrder = request.getParameter( PARAMETER_ORDER );

         //String strRss = request.getParameter( PARAMETER_RSS );
         String strFieldError = NoticeUtils.EMPTY_STRING;

         /*if ( !RssLibraryService.getInstance(  ).isAvailable(  ) )
         {
             strRss = CONSTANTE_EMPTY_RSS;
         }*/
         if ( ( strTitle == null ) || strTitle.trim(  ).equals( NoticeUtils.EMPTY_STRING ) )
         {
             strFieldError = MESSAGE_FIELD_TITLE;
         }

         else if ( ( ( strMessage == null ) || strMessage.trim(  ).equals( NoticeUtils.EMPTY_STRING ) ) /* &&
             strRss.equals( CONSTANTE_EMPTY_RSS )*/ )
         {
             strFieldError = MESSAGE_FIELD_MESSAGE;
         }

         int nIdNoticeGroup = -1;

         if ( StringUtils.isBlank( strIdNoticeGroup ) )
         {
             strFieldError = MESSAGE_ERROR_NOTICE_GROUP;
         }
         else
         {
             nIdNoticeGroup = NoticeUtils.convertStringToInt( strIdNoticeGroup );

             if ( nIdNoticeGroup == -1 )
             {
                 strFieldError = MESSAGE_ERROR_NOTICE_GROUP;
             }
         }

         if ( !strFieldError.equals( NoticeUtils.EMPTY_STRING ) )
         {
             Object[] tabRequiredFields = { I18nService.getLocalizedString( strFieldError, getLocale(  ) ) };

             return AdminMessageService.getMessageUrl( request, MESSAGE_NOTICE_MANDATORY, tabRequiredFields,
                 AdminMessage.TYPE_STOP );
         }

         notice.setTitle( strTitle );
         notice.setMessage( strMessage );
         notice.setWorkgroupKey( strWorkgroup );
         notice.setIdNoticeGroup( nIdNoticeGroup );

         try
         {
             int nMailingListId = Integer.parseInt( strMailingList );
             notice.setIdDiffusion( nMailingListId );
         }
         catch ( NumberFormatException ne )
         {
             AppLogService.error( ne );

             return getHomeUrl( request );
         }

         /*try
         {
             int nRssId = Integer.parseInt( strRss );
             notice.setIdRss( nRssId );
         }
         catch ( NumberFormatException ne )
         {
             AppLogService.error( ne );

             return getHomeUrl( request );
         }*/

         /*if ( ( notice.getIdRss(  ) != -1 ) && RssLibraryService.getInstance(  ).isAvailable(  ) )
         {
             String rssContent = RssLibraryService.getInstance(  ).getRssContent( notice.getIdRss(  ) );
             String strXslTransform = "";
             Properties outputProperties = XslOutputPropertiesLoader.getOutputProperties(  );

             String strXslDirectory = AppPathService.getPath( CONSTANTE_XSL_PATH );
             String strXslPath = strXslDirectory + "/" + CONSTANTE_XSL_RSS;

             File fileXsl = new File( strXslPath );
             StreamSource sourceStyleSheet = new StreamSource( fileXsl );
             StringReader srInput = new StringReader( rssContent );
             StreamSource sourceDocument = new StreamSource( srInput );

             try
             {
                 XmlTransformerService xmlTransformerService = new XmlTransformerService(  );
                 strXslTransform = xmlTransformerService.transformBySourceWithXslCache( sourceDocument,
                         sourceStyleSheet, strXslPath, null, outputProperties );
             }
             catch ( Exception e )
             {
                 AppLogService.error( e.getMessage(  ) );
             }

             notice.setMessage( strXslTransform );
         }*/
         Timestamp tDateDebut = null;
         Timestamp tDateFin = null;

         if ( ( strDateDebut != null ) && !strDateDebut.equals( NoticeUtils.EMPTY_STRING ) )
         {
             tDateDebut = NoticeUtils.getDate( strDateDebut, true );
             notice.setDateDebut( tDateDebut );
         }

         if ( ( strDateFin != null ) && !strDateFin.equals( NoticeUtils.EMPTY_STRING ) )
         {
             tDateFin = NoticeUtils.getDate( strDateFin, false );
             notice.setDateFin( tDateFin );
             NoticeUtils.getTime( tDateFin );
         }

         if ( ( tDateFin != null ) && ( tDateDebut != null ) )
         {
             if ( tDateFin.compareTo( tDateDebut ) < 0 )
             {
                 Object[] tabErrorDate = null;

                 return AdminMessageService.getMessageUrl( request, MESSAGE_ERROR_DATE, tabErrorDate,
                     AdminMessage.TYPE_STOP );
             }
         }

         return null; // No error
     }

     /**
      * Returns the confirmation to remove the notice
      *
      * @param request The Http request
      * @return the confirmation page
      */
     public String getRemoveNotice( HttpServletRequest request )
     {
         UrlItem url = new UrlItem( JSP_DO_REMOVE_NOTICE );
         url.addParameter( PARAMETER_ID_NOTICE, request.getParameter( PARAMETER_ID_NOTICE ) );

         return AdminMessageService.getMessageUrl( request, MESSAGE_CONFIRM_REMOVE_NOTICE, url.getUrl(  ),
             AdminMessage.TYPE_CONFIRMATION );
     }

     /**
      * Perform the notice supression
      * @param request The HTTP request
      * @return The URL to go after performing the action
      */
     public String doRemoveNotice( HttpServletRequest request )
     {
         String strIdNotice = request.getParameter( PARAMETER_ID_NOTICE );
         Plugin plugin = getPlugin(  );
         int nIdNotice = -1;

         if ( request.getParameter( PARAMETER_ID_NOTICE ) == null )
         {
             return getHomeUrl( request );
         }

         try
         {
             nIdNotice = Integer.parseInt( strIdNotice );
         }
         catch ( NumberFormatException ne )
         {
             AppLogService.error( ne );
         }

         if ( ( nIdNotice != -1 ) )
         {
             NoticeHome.remove( nIdNotice, plugin );
         }

         return getJspManageNotice( request );
     }

     /**
     * return url of the jsp manage notice
     * @param request The HTTP request
     * @return url of the jsp manage notice
     */
     private String getJspManageNotice( HttpServletRequest request )
     {
         return AppPathService.getBaseUrl( request ) + JSP_MANAGE_NOTICE;
     }

     /**
      * JSP notice group management url
      * @param request the request
      * @return the url
      */
     private String getJspManageNoticeGroup( HttpServletRequest request )
     {
         return AppPathService.getBaseUrl( request ) + JSP_MANAGE_NOTICE_GROUP;
     }

     /**
      * convert string to date
      * @param sDate the date to format
      * @return the date
      */
     public static java.util.Date stringToDate( String sDate )
     {
         SimpleDateFormat sdf = new SimpleDateFormat( "dd/MM/yyyy" );
         java.util.Date date = null;

         try
         {
             date = sdf.parse( sDate );
         }
         catch ( Exception e )
         {
             AppLogService.error( e );
         }

         return date;
     }
 }