PortalJspBean.java

/*
 * Copyright (c) 2002-2022, City of 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.portal.web;

import fr.paris.lutece.portal.service.admin.AdminUserService;
import fr.paris.lutece.portal.service.content.ContentPostProcessorService;
import fr.paris.lutece.portal.service.content.ContentService;
import fr.paris.lutece.portal.service.datastore.DatastoreService;
import fr.paris.lutece.portal.service.editor.EditorBbcodeService;
import fr.paris.lutece.portal.service.i18n.I18nService;
import fr.paris.lutece.portal.service.init.AppInfo;
import fr.paris.lutece.portal.service.init.AppInit;
import fr.paris.lutece.portal.service.mail.MailService;
import fr.paris.lutece.portal.service.message.ISiteMessageHandler;
import fr.paris.lutece.portal.service.message.SiteMessage;
import fr.paris.lutece.portal.service.message.SiteMessageException;
import fr.paris.lutece.portal.service.message.SiteMessageService;
import fr.paris.lutece.portal.service.portal.PortalService;
import fr.paris.lutece.portal.service.portal.ThemesService;
import fr.paris.lutece.portal.service.resource.IExtendableResource;
import fr.paris.lutece.portal.service.resource.IExtendableResourceService;
import fr.paris.lutece.portal.service.security.LuteceUser;
import fr.paris.lutece.portal.service.security.SecurityService;
import fr.paris.lutece.portal.service.security.UserNotSignedException;
import fr.paris.lutece.portal.service.spring.SpringContextService;
import fr.paris.lutece.portal.service.template.AppTemplateService;
import fr.paris.lutece.portal.service.util.AppException;
import fr.paris.lutece.portal.service.util.AppLogService;
import fr.paris.lutece.portal.service.util.AppPathService;
import fr.paris.lutece.portal.service.util.AppPropertiesService;
import fr.paris.lutece.portal.web.constants.Markers;
import fr.paris.lutece.portal.web.constants.Parameters;
import fr.paris.lutece.util.html.HtmlTemplate;
import fr.paris.lutece.util.url.UrlItem;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.BooleanUtils;

import java.io.UnsupportedEncodingException;

import java.net.URLEncoder;

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

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

/**
 * This class provides the methods to display the page of the site
 */
public class PortalJspBean
{
    public static final int MODE_HTML = 0;
    public static final int MODE_ADMIN = 1;
    private static final String TEMPLATE_PAGE_ERROR404 = "skin/site/page_error404.html";
    private static final String TEMPLATE_PAGE_ERROR500 = "skin/site/page_error500.html";
    private static final String TEMPLATE_POPUP_CREDITS = "skin/site/popup_credits.html";
    private static final String TEMPLATE_POPUP_LEGAL_INFO = "skin/site/popup_legal_info.html";
    private static final String TEMPLATE_STARTUP_FAILURE = "skin/site/startup_failure.html";
    private static final String TEMPLATE_SEND_RESOURCE = "skin/site/popup_send_resource.html";
    private static final String TEMPLATE_EMAIL_SEND_RESOURCE = "skin/site/mail_send_resource.html";
    private static final String PROPERTY_INFOS_CNIL = "lutece.legal.infos";
    private static final String ATTRIBUTE_LOGIN_NEXT_URL = "luteceLoginNextUrl";
    private static final String ATTRIBUTE_UPLOAD_FILTER_SITE_NEXT_URL = "uploadFilterSiteNextUrl";
    private static final String MARK_PORTAL_DOMAIN = "portal_domain";
    private static final String MARK_ADDRESS_INFOS_CNIL = "confidentiality_info";
    private static final String MARK_APP_VERSION = "app_version";
    private static final String MARK_FAILURE_MESSAGE = "failure_message";
    private static final String MARK_FAILURE_DETAILS = "failure_details";
    private static final String MARK_RESOURCE_URL = "resource_url";
    private static final String MARK_RESOURCE = "resource";
    private static final String MARK_ERROR = "error";
    private static final String MARK_SUCCESS = "success";
    private static final String MARK_ERROR_CAUSE = "error_cause";
    private static final String MARK_PLUGIN_THEME = "plugin_theme";
    private static final String MARK_THEME = "theme";
    private static final String BEAN_SITE_MESSAGE_HANDLER = "siteMessageHandler";
    private static final String PARAMETER_EXTENDABLE_RESOURCE_TYPE = "extendableResourceType";
    private static final String PARAMETER_ID_EXTENDABLE_RESOURCE = "idExtendableResource";
    private static final String PARAMETER_SENDER_NAME = "senderName";
    private static final String PARAMETER_SENDER_FIRST_NAME = "senderFirstname";
    private static final String PARAMETER_SENDER_EMAIL = "senderEmail";
    private static final String PARAMETER_CONTENT = "content";
    private static final String PARAMETER_SEND = "send";
    private static final String MESSAGE_ERROR_WRONG_SENDER_EMAIL = "portal.site.error.wrongEmailFormat";
    private static final String MESSAGE_ERROR_MANDATORY_FIELDS = "portal.util.message.mandatoryFields";
    private static final String MESSAGE_NO_RESOURCE_FOUND = "portal.site.error.noResourceFound";
    private static final String PROPERTY_PAGE_TITLE_ERROR404 = "portal.util.error404.title";
    private static final String PROPERTY_PAGE_TITLE_CREDITS = "portal.site.popup_credits.pageTitle";
    private static final String PROPERTY_PAGE_TITLE_LEGAL_INFO = "portal.site.popup_legal_info.pageTitle";
    private static final String PROPERTY_PAGE_TITLE_STARTUP_FAILURE = "portal.util.startup.failure.title";
    private static final String PROPERTY_PAGE_TITLE_ERROR500 = "portal.util.error500.title";
    private static final String PROPERTY_DEBUG = "error.page.debug";
    private static final String PROPERTY_DEBUG_DEFAULT = "true";
    private static final String CONSTANT_SPACE = " ";
    private static final String KEY_WEBMASTER_EMAIL = "portal.site.site_property.noreply_email";

    /**
     * Returns the content of a page according to the parameters found in the http request. One distinguishes article, page and xpage and the mode.
     *
     * @param request
     *            The http request
     * @return the html code for the display of a page of a site
     * @throws UserNotSignedException
     *             The UserNotSignedException
     * @throws SiteMessageException
     *             occurs when a site message need to be displayed
     */
    public String getContent( HttpServletRequest request ) throws UserNotSignedException, SiteMessageException
    {
        return getContent( request, MODE_HTML );
    }

    /**
     * Returns the content of a page according to the parameters found in the http request. One distinguishes article, page and xpage and the mode.
     *
     * @param request
     *            The http request
     * @param nMode
     *            The mode (normal or administration)
     * @return the html code for the display of a page of a site
     * @throws UserNotSignedException
     *             The UserNotSignedException
     * @throws SiteMessageException
     *             occurs when a site message need to be displayed
     */
    public String getContent( HttpServletRequest request, int nMode ) throws UserNotSignedException, SiteMessageException
    {
        if ( !AppInit.isWebappSuccessfullyLoaded( ) )
        {
            return getStartUpFailurePage( request );
        }

        // Try to register the user in case of external authentication
        if ( SecurityService.isAuthenticationEnable( ) )
        {
            try
            {
                if ( SecurityService.getInstance( ).isExternalAuthentication( ) && !SecurityService.getInstance( ).isMultiAuthenticationSupported( ) )
                {
                    SecurityService.getInstance( ).getRemoteUser( request );
                }
                else
                {
                    LuteceUser user = SecurityService.getInstance( ).getRegisteredUser( request );

                    // no checks are needed if the user is already registered
                    // if multiauthentication is supported, then when have to check remote user
                    // before other check
                    if ( user == null && SecurityService.getInstance( ).isMultiAuthenticationSupported( ) )
                    {

                        // getRemoteUser needs to be checked before any check so the user is registered
                        // getRemoteUser throws an exception if no user found, but here we have to
                        // bypass this exception to display login page.
                        SecurityService.getInstance( ).getRemoteUser( request );
                    }
                }
            }
            catch( UserNotSignedException unse )
            {
                // nothing to do,Leave LuteceAuthenticationFilter testing if the access to the
                // content requires authentication
            }
        }

        // Search the content service invoked and call its getPage method
        ContentService cs = PortalService.getInvokedContentService( request );

        String strContent = ( cs != null ) ? cs.getPage( request, nMode ) : PortalService.getDefaultPage( request, nMode );

        if ( ContentPostProcessorService.hasProcessor( ) )
        {
            strContent = ContentPostProcessorService.process( request, strContent );
        }

        return strContent;
    }

    /**
     * Returns the content of a page according to the parameters found in the http request. One distinguishes article, page and xpage and the mode.
     *
     * @param request
     *            The http request
     * @return the html code for the display of a page of a site
     *
     */
    public String getSiteMessageContent( HttpServletRequest request )
    {
        return getSiteMessageContent( request, MODE_HTML );
    }

    /**
     * Returns the content of a page according to the parameters found in the http request. One distinguishes article, page and xpage and the mode.
     *
     * @param request
     *            The http request
     * @param nMode
     *            The mode (normal or administration)
     * @return the html code for the display of a page of a site
     *
     */
    public String getSiteMessageContent( HttpServletRequest request, int nMode )
    {
        String strContent = null;

        if ( !AppInit.isWebappSuccessfullyLoaded( ) )
        {
            return getStartUpFailurePage( request );
        }

        ISiteMessageHandler handler = SpringContextService.getBean( BEAN_SITE_MESSAGE_HANDLER );

        if ( handler.hasMessage( request ) )
        {
            strContent = handler.getPage( request, nMode );
        }

        return strContent;
    }

    /**
     * Returns the code for the popup of the credits
     * 
     * @param request
     *            The HTTP request
     * @return the html code for the popup credits
     */
    public String getStartUpFailurePage( HttpServletRequest request )
    {
        HashMap<String, Object> model = new HashMap<>( );
        fillPageModel( request, model );
        model.put( MARK_FAILURE_MESSAGE, AppInit.getLoadingFailureCause( ) );
        model.put( MARK_FAILURE_DETAILS, AppInit.getLoadingFailureDetails( ) );
        model.put( Markers.PAGE_TITLE, I18nService.getLocalizedString( PROPERTY_PAGE_TITLE_STARTUP_FAILURE, request.getLocale( ) ) );

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

        return template.getHtml( );
    }

    /**
     * Returns the code for the popup of the credits
     *
     * @param request
     *            The Http Request
     * @return the html code for the popup credits
     */
    public String getCredits( HttpServletRequest request )
    {
        HashMap<String, Object> model = new HashMap<>( );
        fillPageModel( request, model );
        model.put( MARK_APP_VERSION, AppInfo.getVersion( ) );
        model.put( MARK_PORTAL_DOMAIN, PortalService.getSiteName( ) );
        model.put( Markers.PAGE_TITLE, I18nService.getLocalizedString( PROPERTY_PAGE_TITLE_CREDITS, request.getLocale( ) ) );

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

        return template.getHtml( );
    }

    /**
     * Returns the code for the popup of the legal infos
     *
     * @param request
     *            The Http Request
     * @return the html code for the legal infos
     */
    public String getLegalInfos( HttpServletRequest request )
    {
        HashMap<String, Object> model = new HashMap<>( );
        fillPageModel( request, model );
        model.put( MARK_ADDRESS_INFOS_CNIL, AppPropertiesService.getProperty( PROPERTY_INFOS_CNIL ) );
        model.put( MARK_PORTAL_DOMAIN, PortalService.getSiteName( ) );
        model.put( Markers.PAGE_TITLE, I18nService.getLocalizedString( PROPERTY_PAGE_TITLE_LEGAL_INFO, request.getLocale( ) ) );

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

        return template.getHtml( );
    }

    /**
     * Returns the 404 Error page
     * 
     * @param request
     *            The HTTP request
     * @return The page
     */
    public String getError404Page( HttpServletRequest request )
    {
        HashMap<String, Object> model = new HashMap<>( );
        fillPageModel( request, model );
        model.put( Markers.PAGE_TITLE, I18nService.getLocalizedString( PROPERTY_PAGE_TITLE_ERROR404, request.getLocale( ) ) );

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

        return template.getHtml( );
    }

    /**
     * Returns the 500 Error page
     * 
     * @param request
     *            The HTTP request
     * @param exception
     *            The Exception
     * @return The page
     */
    public String getError500Page( HttpServletRequest request, Throwable exception )
    {
        if ( exception instanceof AppException )
        {
            // AppException calls AppLogService.error( message, this ) in the
            // constructor, so don't call it here again Call toString to have
            // the Class and the message to be able to indentify the correct
            // stacktrace in the preceding logs.
            AppLogService.error( "Error 500 : Caused by previous Critical AppException" );
        }
        else
        {
            AppLogService.error( "Error 500 : {}", exception.getMessage( ), exception );
        }

        String strCause = null;

        if ( AppPropertiesService.getProperty( PROPERTY_DEBUG, PROPERTY_DEBUG_DEFAULT ).equalsIgnoreCase( "true" ) )
        {
            strCause = exception.getMessage( );

            if ( exception.getCause( ) != null )
            {
                strCause += exception.getCause( ).getMessage( );
            }
        }

        return getError500Page( request, strCause );
    }

    /**
     * Returns the 500 Error page
     * 
     * @param request
     *            The HTTP request
     * @param strCause
     *            The message
     * @return The page
     */
    public String getError500Page( HttpServletRequest request, String strCause )
    {
        HashMap<String, Object> model = new HashMap<>( );
        fillPageModel( request, model );
        model.put( Markers.PAGE_TITLE, I18nService.getLocalizedString( PROPERTY_PAGE_TITLE_ERROR500, request.getLocale( ) ) );
        model.put( MARK_ERROR_CAUSE, strCause );

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

        return template.getHtml( );
    }

    /**
     * Fill the model'map with commons values
     * 
     * @param request
     *            The HTTP request
     * @param model
     *            The map containing the model
     */
    private static void fillPageModel( HttpServletRequest request, HashMap<String, Object> model )
    {
        model.put( Markers.BASE_URL, AppPathService.getBaseUrl( request ) );
        model.put( MARK_PLUGIN_THEME, null );
        model.put( MARK_THEME, ThemesService.getGlobalThemeObject( ) );
    }

    /**
     * This method is called by Portal.jsp when it caught an UserNotSignedException. It gives the login url and stores in the session the url asked
     * 
     * @param request
     *            The HTTP request
     * @return The login page URL
     * @since v1.1
     */
    public static String redirectLogin( HttpServletRequest request )
    {
        String strNextUrl = request.getRequestURI( );
        UrlItem url = new UrlItem( strNextUrl );
        Enumeration<String> enumParams = request.getParameterNames( );

        while ( enumParams.hasMoreElements( ) )
        {
            String strParamName = enumParams.nextElement( );

            try
            {
                url.addParameter( strParamName, URLEncoder.encode( request.getParameter( strParamName ), "UTF-8" ) );
            }
            catch( UnsupportedEncodingException ex )
            {
                AppLogService.error( "Redirection error while encoding URL : {}", ex.getMessage( ), ex );
            }
        }

        HttpSession session = request.getSession( true );
        session.setAttribute( ATTRIBUTE_LOGIN_NEXT_URL, url.getUrl( ) );

        String strRedirect = SecurityService.getInstance( ).getLoginPageUrl( );

        return AppPathService.getAbsoluteUrl( request, strRedirect );
    }

    /**
     * Returns the url (asked before login) to redirect after login
     * 
     * @param request
     *            The Http request
     * @return The url asked before login
     * @since v1.1
     */
    public static String getLoginNextUrl( HttpServletRequest request )
    {
        HttpSession session = request.getSession( );
        return (String) session.getAttribute( ATTRIBUTE_LOGIN_NEXT_URL );
    }

    /**
     * Set the upload filter site next url
     * 
     * @param request
     *            the HTTP request
     */
    public static void setUploadFilterSiteNextUrl( HttpServletRequest request )
    {
        String strNextUrl = request.getRequestURI( );
        UrlItem url = new UrlItem( strNextUrl );
        Enumeration<String> enumParams = request.getParameterNames( );

        while ( enumParams.hasMoreElements( ) )
        {
            String strParamName = enumParams.nextElement( );
            url.addParameter( strParamName, request.getParameter( strParamName ) );
        }

        HttpSession session = request.getSession( true );
        session.setAttribute( ATTRIBUTE_UPLOAD_FILTER_SITE_NEXT_URL, url.getUrl( ) );
    }

    /**
     * Get the upload filter site next url
     * 
     * @param request
     *            the HTTP request
     * @return the next url
     */
    public static String getUploadFilterSiteNextUrl( HttpServletRequest request )
    {
        HttpSession session = request.getSession( );
        return (String) session.getAttribute( ATTRIBUTE_UPLOAD_FILTER_SITE_NEXT_URL );
    }

    /**
     * Remove the upload filter next url from the session
     * 
     * @param request
     *            the HTTP request
     */
    public static void removeUploadFilterSiteNextUrl( HttpServletRequest request )
    {
        HttpSession session = request.getSession( );
        session.removeAttribute( ATTRIBUTE_UPLOAD_FILTER_SITE_NEXT_URL );
    }

    /**
     * Do send a resource
     * 
     * @param request
     *            The request
     * @return The HTML content to display
     * @throws SiteMessageException
     *             If the resource or its associated service is not found
     */
    public static String sendResource( HttpServletRequest request ) throws SiteMessageException
    {
        String strSenderEmail = DatastoreService.getDataValue( KEY_WEBMASTER_EMAIL, "no-reply@mydomain.com" );
        String strSenderName = request.getParameter( PARAMETER_SENDER_NAME );
        String strSenderFirstName = request.getParameter( PARAMETER_SENDER_FIRST_NAME );
        String strReceipientEmail = request.getParameter( Parameters.EMAIL );
        String strContent = request.getParameter( PARAMETER_CONTENT );
        String strExtendableResourceType = request.getParameter( PARAMETER_EXTENDABLE_RESOURCE_TYPE );
        String strIdExtendableResource = request.getParameter( PARAMETER_ID_EXTENDABLE_RESOURCE );
        String strSend = request.getParameter( PARAMETER_SEND );
        IExtendableResource resource = null;

        String strError = checkSendParams( strSend, strSenderEmail, strSenderName, strSenderFirstName, strReceipientEmail, strContent, request.getLocale( ) );

        // We get the resource from its resource service
        IExtendableResourceService resourceService = null;
        List<IExtendableResourceService> listExtendableResourceService = SpringContextService.getBeansOfType( IExtendableResourceService.class );

        for ( IExtendableResourceService extendableResourceService : listExtendableResourceService )
        {
            if ( extendableResourceService.isInvoked( strExtendableResourceType ) )
            {
                resourceService = extendableResourceService;
                resource = extendableResourceService.getResource( strIdExtendableResource, strExtendableResourceType );
            }
        }

        if ( ( resourceService == null ) || ( resource == null ) )
        {
            SiteMessageService.setMessage( request, MESSAGE_NO_RESOURCE_FOUND, SiteMessage.TYPE_ERROR );
            throw new SiteMessageException( );
        }

        String strResourceUrl = resourceService.getResourceUrl( strIdExtendableResource, strExtendableResourceType );
        Map<String, Object> model = new HashMap<>( );
        model.put( MARK_RESOURCE, resource );
        model.put( MARK_RESOURCE_URL, strResourceUrl );
        model.put( Markers.BASE_URL, AppPathService.getBaseUrl( request ) );

        if ( ( strSend != null ) && ( strError == null ) )
        {
            Map<String, Object> mailModel = new HashMap<>( );
            mailModel.put( Markers.BASE_URL, AppPathService.getBaseUrl( request ) );
            mailModel.put( MARK_RESOURCE, resource );
            mailModel.put( PARAMETER_SENDER_EMAIL, strSenderEmail );
            mailModel.put( PARAMETER_SENDER_NAME, strSenderName );
            mailModel.put( PARAMETER_SENDER_FIRST_NAME, strSenderFirstName );
            mailModel.put( Parameters.EMAIL, strReceipientEmail );
            mailModel.put( PARAMETER_CONTENT, EditorBbcodeService.getInstance( ).parse( strContent ) );
            mailModel.put( MARK_RESOURCE_URL, resourceService.getResourceUrl( strIdExtendableResource, strExtendableResourceType ) );

            HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_EMAIL_SEND_RESOURCE, request.getLocale( ), mailModel );
            MailService.sendMailHtml( strReceipientEmail, strSenderFirstName + CONSTANT_SPACE + strSenderName, strSenderEmail,
                    resource.getExtendableResourceName( ), template.getHtml( ) );
            model.put( MARK_SUCCESS, MARK_SUCCESS );
        }
        else
        {
            model.put( PARAMETER_SENDER_NAME, strSenderName );
            model.put( PARAMETER_SENDER_FIRST_NAME, strSenderFirstName );
            model.put( Parameters.EMAIL, strReceipientEmail );
            model.put( PARAMETER_CONTENT, strContent );
            model.put( MARK_ERROR, strError );
        }

        model.put( Markers.PAGE_MAIN_MENU, StringUtils.EMPTY );

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

        return template.getHtml( );
    }

    private static String checkSendParams( String strSend, String strSenderEmail, String strSenderName, String strSenderFirstName, String strReceipientEmail,
            String strContent, Locale locale )
    {
        String strError = null;
        // If the form was submited, we check data
        if ( strSend != null )
        {
            boolean [ ] conditions = new boolean [ ] {
                    StringUtils.isBlank( strSenderEmail ), StringUtils.isBlank( strSenderName ), StringUtils.isBlank( strSenderFirstName ),
                    StringUtils.isBlank( strReceipientEmail ), StringUtils.isBlank( strContent )
            };

            if ( BooleanUtils.or( conditions ) )
            {
                strError = I18nService.getLocalizedString( MESSAGE_ERROR_MANDATORY_FIELDS, locale );
            }

            if ( ( strError != null ) && ( !AdminUserService.checkEmail( strSenderEmail ) || !AdminUserService.checkEmail( strReceipientEmail ) ) )
            {
                strError = I18nService.getLocalizedString( MESSAGE_ERROR_WRONG_SENDER_EMAIL, locale );
            }
        }
        return strError;
    }
}