AnnounceSubscriptionProvider

/*
 * Copyright (c) 2002-2021, 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.plugins.announce.service;

import fr.paris.lutece.plugins.announce.business.*;
import fr.paris.lutece.plugins.announce.web.AnnounceApp;
import fr.paris.lutece.plugins.module.announce.subscribe.business.AnnounceSubscribtionDTO;
import fr.paris.lutece.plugins.module.announce.subscribe.service.AnnounceSubscriptionService;
import fr.paris.lutece.plugins.subscribe.business.Subscription;
import fr.paris.lutece.plugins.subscribe.business.SubscriptionFilter;
import fr.paris.lutece.plugins.subscribe.service.ISubscriptionProviderService;
import fr.paris.lutece.portal.service.security.LuteceUser;
import fr.paris.lutece.portal.service.security.LuteceUserService;
import fr.paris.lutece.portal.service.spring.SpringContextService;
import fr.paris.lutece.portal.service.template.AppTemplateService;
import fr.paris.lutece.portal.web.LocalVariables;
import fr.paris.lutece.util.html.HtmlTemplate;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;

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

/**
 * Subscription provider service for announces
 */
public class AnnounceSubscriptionProvider implements ISubscriptionProviderService
{
    /**
     * Subscription key to subscribe to announces published by users
     */
    public static final String SUBSCRIPTION_USER = "announce_user";

    /**
     * Subscription key to subscribe to announces of a given category
     */
    public static final String SUBSCRIPTION_CATEGORY = "announce_category";

    /**
     * Subscription key to subscribe to announces matching a filter
     */
    public static final String SUBSCRIPTION_FILTER = "announce_filter";

    // Markers
    private static final String MARK_FILTER = "filter";
    private static final String MARK_CATEGORY = "category";
    private static final String MARK_USER_NAME = "user_name";
    private static final String MARK_USER = "user";
    private static final String PROVIDER_NAME = "announce.announceSubscriptionProvider";
    private static final String BEAN_NAME = "announce.announceSubscriptionProvider";

    // Templates
    private static final String TEMPLATE_FILTER_SUBSCRIPTION_DESCRIPTION = "skin/plugins/announce/subscription/filter_subscriction_description.html";
    private static final String TEMPLATE_USER_SUBSCRIPTION_DESCRIPTION = "skin/plugins/announce/subscription/user_subscriction_description.html";
    private static final String TEMPLATE_CATEGORY_SUBSCRIPTION_DESCRIPTION = "skin/plugins/announce/subscription/category_subscriction_description.html";
    private static volatile AnnounceSubscriptionProvider _instance;

    /**
     * {@inheritDoc}
     */
    @Override
    public String getProviderName( )
    {
        return PROVIDER_NAME;
    }

    /**
     * Get the instance of the service
     *
     * @return The instance of the service
     */
    public static AnnounceSubscriptionProvider getService( )
    {
        if ( _instance == null )
        {
            _instance = SpringContextService.getBean( BEAN_NAME );
        }

        return _instance;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getSubscriptionHtmlDescription( LuteceUser user, String strSubscriptionKey, String strIdSubscribedResource, Locale locale )
    {
        if ( StringUtils.equals( SUBSCRIPTION_USER, strSubscriptionKey ) )
        {
            Map<String, Object> model = new HashMap<>( );
            LuteceUser subscribedUser = LuteceUserService.getLuteceUserFromName( strIdSubscribedResource );

            model.put( MARK_USER_NAME, strIdSubscribedResource );
            model.put( MARK_USER, subscribedUser );

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

            return template.getHtml( );
        }
        else
            if ( StringUtils.equals( SUBSCRIPTION_CATEGORY, strSubscriptionKey ) )
            {
                Map<String, Object> model = new HashMap<>( );

                int nIdCategory = Integer.parseInt( strIdSubscribedResource );

                model.put( MARK_CATEGORY, CategoryHome.findByPrimaryKey( nIdCategory ) );

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

                return template.getHtml( );
            }
            else
                if ( StringUtils.equals( SUBSCRIPTION_FILTER, strSubscriptionKey ) )
                {
                    AnnounceSearchFilter filter = AnnounceSearchFilterHome.findByPrimaryKey( Integer.parseInt( strIdSubscribedResource ) );
                    Map<String, Object> model = new HashMap<>( );
                    model.put( MARK_FILTER, filter );

                    if ( filter.getIdCategory( ) > 0 )
                    {
                        model.put( MARK_CATEGORY, CategoryHome.findByPrimaryKey( filter.getIdCategory( ) ) );
                    }

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

                    return template.getHtml( );
                }

        return StringUtils.EMPTY;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getSubscriptionHtmlDescriptionBis( LuteceUser user, String strSubscriptionKey, String strIdSubscribedResource, Locale locale, String userSub )
    {
        if ( StringUtils.equals( SUBSCRIPTION_USER, strSubscriptionKey ) )
        {
            Map<String, Object> model = new HashMap<>( );

            List<Announce> listAnn = AnnounceHome.findAllPublished( AnnounceSort.DEFAULT_SORT );
            String strUserSub = "";
            for ( Announce ann : listAnn )
            {
                if ( userSub.compareTo( ann.getUserName( ) ) == 0 )
                {
                    strUserSub = ann.getUserLastName( ) + " " + ann.getUserSecondName( );
                    break;
                }
            }

            model.put( MARK_USER_NAME, strIdSubscribedResource );
            model.put( "strUserSub", strUserSub );

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

            return template.getHtml( );
        }
        else
            if ( StringUtils.equals( SUBSCRIPTION_CATEGORY, strSubscriptionKey ) )
            {
                Map<String, Object> model = new HashMap<>( );

                int nIdCategory = Integer.parseInt( strIdSubscribedResource );

                model.put( MARK_CATEGORY, CategoryHome.findByPrimaryKey( nIdCategory ) );

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

                return template.getHtml( );
            }
            else
                if ( StringUtils.equals( SUBSCRIPTION_FILTER, strSubscriptionKey ) )
                {
                    AnnounceSearchFilter filter = AnnounceSearchFilterHome.findByPrimaryKey( Integer.parseInt( strIdSubscribedResource ) );
                    Map<String, Object> model = new HashMap<>( );
                    model.put( MARK_FILTER, filter );

                    if ( filter.getIdCategory( ) > 0 )
                    {
                        model.put( MARK_CATEGORY, CategoryHome.findByPrimaryKey( filter.getIdCategory( ) ) );
                    }

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

                    return template.getHtml( );
                }

        return StringUtils.EMPTY;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean isSubscriptionRemovable( LuteceUser user, String strSubscriptionKey, String strIdSubscribedResource )
    {
        // Subscriptions to user and filters are always removable
        return true;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getUrlModifySubscription( LuteceUser user, String strSubscriptionKey, String strIdSubscribedResource )
    {
        if ( StringUtils.equals( SUBSCRIPTION_FILTER, strSubscriptionKey ) )
        {
            int nIdFilter = ( StringUtils.isNotEmpty( strIdSubscribedResource ) && StringUtils.isNumeric( strIdSubscribedResource ) )
                    ? Integer.parseInt( strIdSubscribedResource )
                    : 0;

            if ( nIdFilter > 0 )
            {
                return AnnounceApp.getUrlSearchAnnounce( LocalVariables.getRequest( ), nIdFilter );
            }
        }
        else
            if ( StringUtils.equals( SUBSCRIPTION_USER, strSubscriptionKey ) )
            {
                return AnnounceApp.getUrlViewUserAnnounces( LocalVariables.getRequest( ), strIdSubscribedResource );
            }
            else
                if ( StringUtils.equals( SUBSCRIPTION_CATEGORY, strSubscriptionKey ) )
                {
                    int nIdCategory = ( StringUtils.isNotEmpty( strIdSubscribedResource ) && StringUtils.isNumeric( strIdSubscribedResource ) )
                            ? Integer.parseInt( strIdSubscribedResource )
                            : 0;

                    return AnnounceApp.getUrlViewCategory( LocalVariables.getRequest( ), nIdCategory );
                }

        return null;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void notifySubscriptionRemoval( Subscription subscription )
    {
        if ( StringUtils.equals( subscription.getSubscriptionKey( ), SUBSCRIPTION_FILTER ) && StringUtils.isNotEmpty( subscription.getIdSubscribedResource( ) )
                && StringUtils.isNumeric( subscription.getIdSubscribedResource( ) ) )
        {
            int nIdFilter = Integer.parseInt( subscription.getIdSubscribedResource( ) );
            AnnounceSearchFilterHome.delete( nIdFilter );
        }

        // We do nothing for users and category subscriptions
    }

    /**
     * Create a subscription to a user
     *
     * @param user
     *            The user that subscribe to another one
     * @param strUserName
     *            The name of the user to subscribe to
     */
    public void createSubscriptionToUser( LuteceUser user, String strUserName )
    {
        createSubscription( user, strUserName, SUBSCRIPTION_USER );
    }

    /**
     * Create a subscription to a filter
     *
     * @param user
     *            The user that subscribe to the filter
     * @param nIdFilter
     *            The id of the filter to subscribe to
     */
    public void createSubscriptionToFilter( LuteceUser user, int nIdFilter )
    {
        createSubscription( user, Integer.toString( nIdFilter ), SUBSCRIPTION_FILTER );
    }

    /**
     * Create a subscription to a category
     *
     * @param user
     *            The user that subscribe to the category
     * @param nIdCategory
     *            The id of the category to subscribe to
     */
    public void createSubscriptionToCategory( LuteceUser user, int nIdCategory )
    {
        createSubscription( user, Integer.toString( nIdCategory ), SUBSCRIPTION_CATEGORY );
    }

    /**
     * Remove a subscription to a user
     *
     * @param user
     *            The user that subscribe to another one
     * @param strUserName
     *            The name of the user to subscribe to
     */
    public void removeSubscriptionToUser( LuteceUser user, String strUserName )
    {
        removeSubscription( user, strUserName, SUBSCRIPTION_USER );
    }

    /**
     * Remove a subscription to a filter
     *
     * @param user
     *            The user that subscribe to the filter
     * @param nIdFilter
     *            The id of the filter to subscribe to
     */
    public void removeSubscriptionToFilter( LuteceUser user, int nIdFilter )
    {
        removeSubscription( user, Integer.toString( nIdFilter ), SUBSCRIPTION_FILTER );
    }

    /**
     * Remove a subscription to a category
     *
     * @param user
     *            The user that subscribe to the category
     * @param nIdCategory
     *            The id of the category to subscribe to
     */
    public void removeSubscriptionToCategory( LuteceUser user, int nIdCategory )
    {
        removeSubscription( user, Integer.toString( nIdCategory ), SUBSCRIPTION_CATEGORY );
    }

    /**
     * Do create a subscription to a user, a filter or a category
     *
     * @param user
     *            The user to subscribe to
     * @param strIdResource
     *            the id of the resource to subscribe to
     * @param strSubscriptionKey
     *            The subscription key
     */
    private void createSubscription( LuteceUser user, String strIdResource, String strSubscriptionKey )
    {
        AnnounceSubscribtionDTO subscription = new AnnounceSubscribtionDTO( );
        subscription.setIdSubscribedResource( strIdResource );
        subscription.setSubscriptionKey( strSubscriptionKey );
        subscription.setSubscriptionProvider( getProviderName( ) );
        subscription.setUserId( user.getName( ) );
        subscription.setEmailSubscribes( user.getUserInfo( LuteceUser.BUSINESS_INFO_ONLINE_EMAIL ) );
        AnnounceSubscriptionService.getInstance( ).createSubscription( subscription );
    }

    /**
     * Do remove a subscription
     *
     * @param user
     *            The user
     * @param strIdResource
     *            The id of the resource to remove the subscription to
     * @param strSubscriptionKey
     *            The subscription key of the subscription to remove
     */
    private void removeSubscription( LuteceUser user, String strIdResource, String strSubscriptionKey )
    {
        SubscriptionFilter filter = new SubscriptionFilter( user.getName( ), getProviderName( ), strSubscriptionKey, strIdResource );
        List<AnnounceSubscribtionDTO> listSubscriptions = AnnounceSubscriptionService.getInstance( ).findByFilter( filter );

        for ( AnnounceSubscribtionDTO subscription : listSubscriptions )
        {
            AnnounceSubscriptionService.getInstance( ).removeSubscription( subscription, false );
        }
    }

    /**
     * Check if a user has subscribed to another user
     *
     * @param user
     *            The subscriber user
     * @param userName
     *            The name of the subscribed user
     * @return True if the user has subscribed to another user, false otherwise
     */
    public boolean hasSubscribedToUser( LuteceUser user, String userName )
    {
        return hasSubscribedtoResource( user, userName, SUBSCRIPTION_USER );
    }

    /**
     * Check if a user has subscribed to a category
     *
     * @param user
     *            The subscriber user
     * @param nIdCategory
     *            The id of the subscribed category
     * @return True if the user has subscribed to a category, false otherwise
     */
    public boolean hasSubscribedToCategory( LuteceUser user, int nIdCategory )
    {
        if ( nIdCategory == 0 )
        {
            return false;
        }

        return hasSubscribedtoResource( user, Integer.toString( nIdCategory ), SUBSCRIPTION_CATEGORY );
    }

    /**
     * Check if a user has subscribed to a given resource
     *
     * @param user
     *            The user to check the subscription of
     * @param strIdResource
     *            The id of the resource
     * @param strSubscriptionKey
     *            The subscription key
     * @return True if the user has subscribed to the given resource, false otherwise
     */
    private boolean hasSubscribedtoResource( LuteceUser user, String strIdResource, String strSubscriptionKey )
    {
        SubscriptionFilter filter = new SubscriptionFilter( user.getName( ), getProviderName( ), strSubscriptionKey, strIdResource );
        List<AnnounceSubscribtionDTO> listSubscription = AnnounceSubscriptionService.getInstance( ).findByFilter( filter );

        return CollectionUtils.isNotEmpty( listSubscription );
    }

    /**
     * Get the list of subscriptions to users
     *
     * @return The list of subscriptions to users
     */
    public List<AnnounceSubscribtionDTO> getSubscriptionsToUsers( )
    {
        return getSubscriptionsToResource( SUBSCRIPTION_USER );
    }

    /**
     * Get the list of subscriptions to categories
     *
     * @return The list of subscriptions to categories
     */
    public List<AnnounceSubscribtionDTO> getsubscriptionsToCategories( )
    {
        return getSubscriptionsToResource( SUBSCRIPTION_CATEGORY );
    }

    /**
     * Get the list of subscriptions to filters
     *
     * @return The list of subscriptions to filters
     */
    public List<AnnounceSubscribtionDTO> getSubscriptionsToFilters( )
    {
        return getSubscriptionsToResource( SUBSCRIPTION_FILTER );
    }

    /**
     * Get the list of subscriptions of a given type
     *
     * @param strSubscriptionKey
     *            The type of subscriptions to get
     * @return The list of subscriptions of the given type
     */
    public List<AnnounceSubscribtionDTO> getSubscriptionsToResource( String strSubscriptionKey )
    {
        SubscriptionFilter filter = new SubscriptionFilter( );
        filter.setSubscriptionKey( strSubscriptionKey );
        filter.setSubscriptionProvider( getProviderName( ) );

        return AnnounceSubscriptionService.getInstance( ).findByFilter( filter );
    }

    public List<AnnounceSubscribtionDTO> getSubscriptionsByAnnounce( String userId, String categoryId, String numberOfAnnounceToNotify )
    {
        return AnnounceSubscriptionService.getInstance( ).findByFilterOr( userId, categoryId, numberOfAnnounceToNotify );
    }
}