EntryService.java
/*
* Copyright (c) 2002-2020, 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.directories.service;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import fr.paris.lutece.plugins.genericattributes.business.Entry;
import fr.paris.lutece.plugins.genericattributes.business.EntryFilter;
import fr.paris.lutece.plugins.genericattributes.business.EntryHome;
import fr.paris.lutece.plugins.genericattributes.business.Field;
import fr.paris.lutece.plugins.genericattributes.business.FieldHome;
import fr.paris.lutece.plugins.genericattributes.service.entrytype.AbstractEntryTypeUpload;
import fr.paris.lutece.plugins.genericattributes.service.entrytype.EntryTypeServiceManager;
import fr.paris.lutece.plugins.genericattributes.service.entrytype.IEntryTypeService;
import fr.paris.lutece.portal.service.admin.AdminUserService;
import fr.paris.lutece.portal.service.spring.SpringContextService;
import fr.paris.lutece.portal.service.template.AppTemplateService;
import fr.paris.lutece.portal.service.util.RemovalListenerService;
import fr.paris.lutece.util.ReferenceList;
import fr.paris.lutece.util.html.HtmlTemplate;
/**
* Service to manage entries.
*
* @author
*/
public final class EntryService extends RemovalListenerService implements Serializable
{
/** Name of the bean of this service. */
public static final String BEAN_NAME = "directories.entryService";
private static final long serialVersionUID = -5378918040356139703L;
private static final String MARK_ENTRY_LIST = "entry_list";
private static final String MARK_ENTRY_TYPE_LIST = "entry_type_list";
private static final String MARK_GROUP_ENTRY_LIST = "entry_group_list";
private static final String MARK_LIST_ORDER_FIRST_LEVEL = "listOrderFirstLevel";
private static final String MARK_LOCALE = "locale";
private static final String MARK_ENTRY = "entry";
private static final String RESOURCE_TYPE = "DIRECTORIES";
private static final String MARK_UPLOAD_HANDLER = "uploadHandler";
private static final String MARK_ENTRY_TYPE_SERVICE = "entryTypeService";
/**
* Get an instance of the service.
*
* @return An instance of the service
*/
public static EntryService getService( )
{
return SpringContextService.getBean( BEAN_NAME );
}
/**
* Get the html part of the additional entry of the form.
*
* @param nIdEntry
* the entry id
* @param stringBuffer
* the string buffer
* @param locale
* @param bDisplayFront
*/
public static void getHtmlEntry( Map<String, Object> model, int nIdEntry, StringBuilder strBuilder, Locale locale, boolean bDisplayFront )
{
HtmlTemplate template;
Entry entry = EntryHome.findByPrimaryKey( nIdEntry );
List<Field> listField = new ArrayList<>( entry.getFields( ).size( ) );
for ( Field field : entry.getFields( ) )
{
field = FieldHome.findByPrimaryKey( field.getIdField( ) );
listField.add( field );
}
entry.setFields( listField );
model.put( MARK_ENTRY, entry );
model.put( MARK_LOCALE, locale );
IEntryTypeService entryTypeService = EntryTypeServiceManager.getEntryTypeService( entry );
// If the entry type is a file, we add the
if ( entryTypeService instanceof AbstractEntryTypeUpload )
{
model.put( MARK_UPLOAD_HANDLER, ( (AbstractEntryTypeUpload) entryTypeService ).getAsynchronousUploadHandler( ) );
}
template = AppTemplateService.getTemplate( entryTypeService.getTemplateHtmlForm( entry, bDisplayFront ), locale, model );
strBuilder.append( template.getHtml( ) );
}
/**
* Get the html part of the additional entry of the form.
*
* @param nIdEntry
* the entry id
* @param StringBuilder
* the string buffer
* @param locale
* @param bDisplayFront
*/
public static void getHtmlEntryReadOnly( Map<String, Object> model, int nIdEntry, StringBuilder strBuilder, Locale locale, boolean bDisplayFront )
{
HtmlTemplate template;
Entry entry = EntryHome.findByPrimaryKey( nIdEntry );
List<Field> listField = new ArrayList<>( entry.getFields( ).size( ) );
for ( Field field : entry.getFields( ) )
{
field = FieldHome.findByPrimaryKey( field.getIdField( ) );
listField.add( field );
}
entry.setFields( listField );
model.put( MARK_ENTRY, entry );
model.put( MARK_LOCALE, locale );
IEntryTypeService entryTypeService = EntryTypeServiceManager.getEntryTypeService( entry );
model.put( MARK_ENTRY_TYPE_SERVICE, entryTypeService );
// If the entry type is a file, we add the
if ( entryTypeService instanceof AbstractEntryTypeUpload )
{
model.put( MARK_UPLOAD_HANDLER, ( (AbstractEntryTypeUpload) entryTypeService ).getAsynchronousUploadHandler( ) );
}
template = AppTemplateService.getTemplate( entryTypeService.getTemplateEntryReadOnly( bDisplayFront ), locale, model );
strBuilder.append( template.getHtml( ) );
}
/**
* Add the entries to the model.
*
* @param nIdDirectory
* The form Id
* @param model
* the model
*/
public static void addListEntryToModel( Map<String, Object> model, int nIdDirectory )
{
EntryFilter entryFilter = new EntryFilter( );
entryFilter.setIdResource( nIdDirectory );
entryFilter.setResourceType( RESOURCE_TYPE );
entryFilter.setEntryParentNull( EntryFilter.FILTER_TRUE );
entryFilter.setFieldDependNull( EntryFilter.FILTER_TRUE );
List<Entry> listEntryFirstLevel = EntryHome.getEntryList( entryFilter );
List<Entry> listEntry = new ArrayList<>( listEntryFirstLevel.size( ) );
List<Integer> listOrderFirstLevel = new ArrayList<>( listEntryFirstLevel.size( ) );
for ( Entry entry : listEntryFirstLevel )
{
listEntry.add( entry );
listOrderFirstLevel.add( listEntry.size( ) );
if ( entry.getEntryType( ).getGroup( ) )
{
entryFilter = new EntryFilter( );
entryFilter.setIdResource( nIdDirectory );
entryFilter.setResourceType( RESOURCE_TYPE );
entryFilter.setFieldDependNull( EntryFilter.FILTER_TRUE );
entryFilter.setIdEntryParent( entry.getIdEntry( ) );
List<Entry> listEntryGroup = EntryHome.getEntryList( entryFilter );
entry.setChildren( listEntryGroup );
listEntry.addAll( listEntryGroup );
}
}
model.put( MARK_GROUP_ENTRY_LIST, getRefListGroups( nIdDirectory ) );
model.put( MARK_ENTRY_TYPE_LIST, EntryTypeService.getInstance( ).getEntryTypeReferenceList( ) );
model.put( MARK_ENTRY_LIST, listEntry );
model.put( MARK_LIST_ORDER_FIRST_LEVEL, listOrderFirstLevel );
}
/**
* Get the reference list of groups.
*
* @param nIdDirectory
* the id of the directories form
* @return The reference list of groups of the given form
*/
private static ReferenceList getRefListGroups( int nIdDirectory )
{
EntryFilter entryFilter = new EntryFilter( );
entryFilter.setIdResource( nIdDirectory );
entryFilter.setResourceType( RESOURCE_TYPE );
entryFilter.setIdIsGroup( 1 );
List<Entry> listEntry = EntryHome.getEntryList( entryFilter );
ReferenceList refListGroups = new ReferenceList( );
for ( Entry entry : listEntry )
{
refListGroups.addItem( entry.getIdEntry( ), entry.getTitle( ) );
}
return refListGroups;
}
/**
* Change the attribute's order to a greater one (move down in the list).
*
* @param nOrderToSet
* the new order for the attribute
* @param entryToChangeOrder
* the attribute which will change
*/
public void moveDownEntryOrder( int nOrderToSet, Entry entryToChangeOrder )
{
if ( entryToChangeOrder.getParent( ) == null )
{
int nNbChild = 0;
int nNewOrder = 0;
EntryFilter filter = new EntryFilter( );
filter.setIdResource( entryToChangeOrder.getIdResource( ) );
filter.setResourceType( RESOURCE_TYPE );
filter.setEntryParentNull( EntryFilter.FILTER_TRUE );
filter.setFieldDependNull( EntryFilter.FILTER_TRUE );
List<Entry> listEntryFirstLevel = EntryHome.findEntriesWithoutParent( entryToChangeOrder.getIdResource( ), entryToChangeOrder.getResourceType( ) );
List<Integer> orderFirstLevel = new ArrayList<>( );
initOrderFirstLevel( listEntryFirstLevel, orderFirstLevel );
Integer nbChildEntryToChangeOrder = 0;
if ( entryToChangeOrder.getChildren( ) != null )
{
nbChildEntryToChangeOrder = entryToChangeOrder.getChildren( ).size( );
}
for ( Entry entry : listEntryFirstLevel )
{
for ( int i = 0; i < orderFirstLevel.size( ); i++ )
{
if ( orderFirstLevel.get( i ).equals( Integer.valueOf( entry.getPosition( ) ) ) && entry.getPosition( ) > entryToChangeOrder.getPosition( )
&& entry.getPosition( ) <= nOrderToSet )
{
if ( nNbChild == 0 )
{
nNewOrder = orderFirstLevel.get( i - 1 );
if ( !orderFirstLevel.get( i - 1 ).equals( Integer.valueOf( entryToChangeOrder.getPosition( ) ) ) )
{
nNewOrder -= nbChildEntryToChangeOrder;
}
}
else
{
nNewOrder += nNbChild + 1;
}
entry.setPosition( nNewOrder );
EntryHome.update( entry );
nNbChild = 0;
if ( entry.getChildren( ) != null )
{
for ( Entry child : entry.getChildren( ) )
{
nNbChild++;
child.setPosition( nNewOrder + nNbChild );
EntryHome.update( child );
}
}
}
}
}
entryToChangeOrder.setPosition( nNewOrder + nNbChild + 1 );
EntryHome.update( entryToChangeOrder );
nNbChild = 0;
for ( Entry child : entryToChangeOrder.getChildren( ) )
{
nNbChild++;
child.setPosition( entryToChangeOrder.getPosition( ) + nNbChild );
EntryHome.update( child );
}
}
else
{
EntryFilter filter = new EntryFilter( );
filter.setIdResource( entryToChangeOrder.getIdResource( ) );
filter.setResourceType( RESOURCE_TYPE );
filter.setFieldDependNull( EntryFilter.FILTER_TRUE );
List<Entry> listAllEntry = EntryHome.getEntryList( filter );
for ( Entry entry : listAllEntry )
{
if ( entry.getPosition( ) > entryToChangeOrder.getPosition( ) && entry.getPosition( ) <= nOrderToSet )
{
entry.setPosition( entry.getPosition( ) - 1 );
EntryHome.update( entry );
}
}
entryToChangeOrder.setPosition( nOrderToSet );
EntryHome.update( entryToChangeOrder );
}
}
/**
* Change the attribute's order to a lower one (move up in the list).
*
* @param nOrderToSet
* the new order for the attribute
* @param entryToChangeOrder
* the attribute which will change
*/
public void moveUpEntryOrder( int nOrderToSet, Entry entryToChangeOrder )
{
EntryFilter filter = new EntryFilter( );
filter.setIdResource( entryToChangeOrder.getIdResource( ) );
filter.setResourceType( RESOURCE_TYPE );
filter.setFieldDependNull( EntryFilter.FILTER_TRUE );
if ( entryToChangeOrder.getParent( ) == null )
{
filter.setEntryParentNull( EntryFilter.FILTER_TRUE );
List<Integer> orderFirstLevel = new ArrayList<>( );
int nNbChild = 0;
int nNewOrder = nOrderToSet;
int nEntryToMoveOrder = entryToChangeOrder.getPosition( );
List<Entry> listEntryFirstLevel = EntryHome.findEntriesWithoutParent( entryToChangeOrder.getIdResource( ), entryToChangeOrder.getResourceType( ) );
// the list of all the orders in the first level
initOrderFirstLevel( listEntryFirstLevel, orderFirstLevel );
for ( Entry entry : listEntryFirstLevel )
{
Integer entryInitialPosition = entry.getPosition( );
for ( int i = 0; i < orderFirstLevel.size( ); i++ )
{
if ( orderFirstLevel.get( i ).equals( entryInitialPosition ) && entryInitialPosition < nEntryToMoveOrder
&& entryInitialPosition >= nOrderToSet )
{
if ( entryToChangeOrder.getPosition( ) == nEntryToMoveOrder )
{
entryToChangeOrder.setPosition( nNewOrder );
EntryHome.update( entryToChangeOrder );
for ( Entry child : entryToChangeOrder.getChildren( ) )
{
nNbChild++;
child.setPosition( entryToChangeOrder.getPosition( ) + nNbChild );
EntryHome.update( child );
}
}
nNewOrder = nNewOrder + nNbChild + 1;
entry.setPosition( nNewOrder );
EntryHome.update( entry );
nNbChild = 0;
for ( Entry child : entry.getChildren( ) )
{
nNbChild++;
child.setPosition( nNewOrder + nNbChild );
EntryHome.update( child );
}
}
}
}
}
else
{
List<Entry> listAllEntry = EntryHome.getEntryList( filter );
for ( Entry entry : listAllEntry )
{
if ( entry.getPosition( ) < entryToChangeOrder.getPosition( ) && entry.getPosition( ) >= nOrderToSet )
{
entry.setPosition( entry.getPosition( ) + 1 );
EntryHome.update( entry );
}
}
entryToChangeOrder.setPosition( nOrderToSet );
EntryHome.update( entryToChangeOrder );
}
}
/**
* Init the list of the attribute's orders (first level only).
*
* @param listEntryFirstLevel
* the list of all the attributes of the first level
* @param orderFirstLevel
* the list to set
*/
private void initOrderFirstLevel( List<Entry> listEntryFirstLevel, List<Integer> orderFirstLevel )
{
for ( Entry entry : listEntryFirstLevel )
{
orderFirstLevel.add( entry.getPosition( ) );
}
}
/**
* Move EntryToMove into entryGroup.
*
* @param entryToMove
* the entry which will be moved
* @param entryGroup
* the entry group
*/
public void moveEntryIntoGroup( Entry entryToMove, Entry entryGroup )
{
if ( entryToMove != null && entryGroup != null )
{
// If the entry already has a parent, we must remove it before
// adding it to a new one
if ( entryToMove.getParent( ) != null )
{
moveOutEntryFromGroup( entryToMove );
}
int nPosition;
if ( entryToMove.getPosition( ) < entryGroup.getPosition( ) )
{
nPosition = entryGroup.getPosition( );
moveDownEntryOrder( nPosition, entryToMove );
}
else
{
nPosition = entryGroup.getPosition( ) + entryGroup.getChildren( ).size( ) + 1;
moveUpEntryOrder( nPosition, entryToMove );
}
entryToMove.setParent( entryGroup );
EntryHome.update( entryToMove );
}
}
/**
* Remove an entry from a group.
*
* @param entryToMove
* the entry to remove from a group
*/
public void moveOutEntryFromGroup( Entry entryToMove )
{
Entry parent = EntryHome.findByPrimaryKey( entryToMove.getParent( ).getIdEntry( ) );
// The new position of the entry is the position of the group plus the
// number of entries in the group (including this entry)
moveDownEntryOrder( parent.getPosition( ) + parent.getChildren( ).size( ), entryToMove );
entryToMove.setParent( null );
EntryHome.update( entryToMove );
}
/**
* Get the list of directory entries.
*
* @param nIdDirectory
* the directory id
* @param bDisplayFront
* true if it is displayed on FO
* @return the list of entries
*/
public static List<Entry> getDirectoryEntryList( int nIdDirectory, boolean bDisplayFront )
{
EntryFilter filter = new EntryFilter( );
filter.setIdResource( nIdDirectory );
filter.setResourceType( RESOURCE_TYPE );
filter.setEntryParentNull( EntryFilter.FILTER_TRUE );
filter.setFieldDependNull( EntryFilter.FILTER_TRUE );
if ( bDisplayFront )
{
filter.setIsOnlyDisplayInBack( EntryFilter.FILTER_FALSE );
}
List<Entry> listEntry = EntryHome.getEntryList( filter );
getEntryFields( listEntry );
return listEntry;
}
/**
* Get the list of directory entries filtered by type.
*
* @param nIdEntryType
* The Id of EntryType
* @param nIdDirectory
* The id of Directory
* @return the list of entries
*/
public static List<Entry> getEntryListFromType( int nIdEntryType, int nIdDirectory )
{
EntryFilter filter = new EntryFilter( );
filter.setIdEntryType( nIdEntryType );
filter.setIdResource( nIdDirectory );
return EntryHome.getEntryList( filter );
}
/**
* Create or Modify entry
*
* @param entry
* The entry
* @param request
* The Request
* @return The errors
*/
public static String doCreateOrModifyEntry( Entry entry, HttpServletRequest request )
{
return EntryTypeServiceManager.getEntryTypeService( entry ).getRequestData( entry, request, AdminUserService.getLocale( request ) );
}
/**
* fill entries fields
*
* @param listEntry
* The entry list to feed
*/
private static void getEntryFields( List<Entry> listEntry )
{
for ( Entry entry : listEntry )
{
List<Field> listField = new ArrayList<>( );
for ( Field field : EntryHome.findByPrimaryKey( entry.getIdEntry( ) ).getFields( ) )
{
field = FieldHome.findByPrimaryKey( field.getIdField( ) );
listField.add( field );
}
entry.setFields( listField );
}
}
}