EDIT

import javax.servlet.annotation.WebServlet;

import org.hibernate.SessionFactory;

import org.hibernate.event.service.spi.EventListenerRegistry;

import org.hibernate.event.spi.EventType;

@CdmHibernateListener // enable the configuration which activates the TaxonGraphHibernateListener bean

public class CdmVaadinConfiguration implements ApplicationContextAware  {

    public static final String CDM_VAADIN_UI_ACTIVATED = "cdm-vaadin.ui.activated";

    public static final String CDM_SERVICE_MINTER_REGSTRATION_MINID = "cdm.service.minter.registration.minLocalId";

    public static final String CDM_SERVICE_MINTER_REGSTRATION_MAXID = "cdm.service.minter.registration.maxLocalId";

    public static final String CDM_SERVICE_MINTER_REGSTRATION_IDFORMAT = "cdm.service.minter.registration.identifierFormatString";

    @Autowired

    private Environment env;

import org.apache.commons.beanutils.PropertyUtils;

import org.apache.commons.beanutils.PropertyUtilsBean;

import org.apache.commons.lang.builder.HashCodeBuilder;

import org.hibernate.Hibernate;

import org.hibernate.collection.internal.AbstractPersistentCollection;

import org.hibernate.envers.internal.entities.mapper.relation.lazy.proxy.CollectionProxy;

/**

 * @author a.kohlbecker

 * @since 08.11.2017

 */

public class CdmEntityCache implements EntityCache {

    protected static final String COPY_ENTITY = "!";

import java.util.Set;

import java.util.UUID;

import org.hibernate.Session;

import org.springframework.context.event.ContextRefreshedEvent;

import org.springframework.security.authentication.AuthenticationCredentialsNotFoundException;

import eu.etaxonomy.cdm.api.application.AbstractDataInserter;

import eu.etaxonomy.cdm.api.application.CdmRepository;

import eu.etaxonomy.cdm.api.service.pager.Pager;

import eu.etaxonomy.cdm.model.agent.Institution;

import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;

import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;

 */

public class RegistrationRequiredDataInserter extends AbstractDataInserter {

//    protected static final String PARAM_NAME_CREATE = "registrationCreate";

//

//    protected static final String PARAM_NAME_WIPEOUT = "registrationWipeout";

    private static final EnumSet<CRUD> CREATE_READ = EnumSet.of(CRUD.CREATE, CRUD.READ);

    private static final EnumSet<CRUD> CREATE_READ_UPDATE_DELETE = EnumSet.of(CRUD.CREATE, CRUD.READ, CRUD.UPDATE, CRUD.DELETE);

//    private ExtensionType extensionTypeIAPTRegData;

                    return repo.getSession();

                }

            };

            int chunksize = 1000;

            int pageIndex = 0;

            TransactionStatus tx;

import java.io.PrintStream;

import org.hibernate.Session;

import eu.etaxonomy.cdm.cache.CdmEntityCache;

/**

 * @author a.kohlbecker

 * @since 08.11.2017

 */

public class PersistentContextAnalyzer extends CdmEntityCache {

    private static final char HASH_SEPARATOR = '.';

    private static final String IN_PERSITENT_CONTEXT = "*";

    private Session session;

    private boolean showHashCodes = false;

    public PersistentContextAnalyzer(CdmBase entity, Session session){

        this.session = session;

        this.entities.add(entity);

import java.util.Arrays;

import java.util.List;

import org.hibernate.Session;

import org.hibernate.criterion.Criterion;

import org.vaadin.viritin.fields.LazyComboBox.FilterableCountProvider;

/**

 * @author a.kohlbecker

 * @since Jun 7, 2017

 */

public class CdmFilterablePagingProvider<T extends IdentifiableEntity, V extends T> implements FilterablePagingProvider<V>, FilterableCountProvider {

    private static final List<String> DEFAULT_INIT_STRATEGY = Arrays.asList("$");

    public static final String QUERY_STRING_PLACEHOLDER = "{query-string}";

    private int pageSize = 20;

*/

package eu.etaxonomy.cdm.service;

import org.hibernate.Session;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

@ViewScope

public class CdmStore {

    @Autowired

    @Qualifier("cdmRepository")

import java.util.List;

import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.stereotype.Service;

/**

 * @author a.kohlbecker

 * @since Mar 25, 2019

 */

@Service("registrationWorkflowService")

public class RegistrationWorkflowService implements IRegistrationWorkflowService {

    @Autowired

    @Qualifier("cdmRepository")

import java.util.Map;

import java.util.UUID;

import org.vaadin.viritin.fields.LazyComboBox.FilterableCountProvider;

import com.vaadin.data.Property.ValueChangeListener;

 */

public class TaxonNameStringFilterablePagingProvider implements FilterableStringRepresentationPagingProvider<UUID>, FilterableCountProvider {

    private int pageSize = 20;

import java.util.Optional;

import org.apache.commons.lang3.StringUtils;

import org.vaadin.addon.leaflet.LCircle;

import org.vaadin.addon.leaflet.LMap;

import org.vaadin.addon.leaflet.LMarker;

/**

 * @author a.kohlbecker

 * @since Jun 22, 2017

 */

public class GeoLocationField extends CompositeCustomField<Point> {

    private static final long serialVersionUID = 1122123034547920390L;

    private static final String PRIMARY_STYLE = "v-geolocation-field";

    private CssLayout mapWrapper;

    public GeoLocationField() {

        super();

    }

        setCaption(caption);

    }

    @Override

    protected Component initContent() {

        super.setPrimaryStyleName(PRIMARY_STYLE);

        return root;

    }

    protected void updateMap() {

        Double longitude  = null;

import java.util.List;

import java.util.Optional;

import org.vaadin.viritin.fields.LazyComboBox;

import com.vaadin.data.Validator.InvalidValueException;

/**

 * @author a.kohlbecker

 * @since May 11, 2017

 */

public class TeamOrPersonField extends CompositeCustomField<TeamOrPersonBase<?>> {

    private static final long serialVersionUID = 660806402243118112L;

    private static final String PRIMARY_STYLE = "v-team-or-person-field";

import java.util.Map;

import java.util.UUID;

import com.vaadin.server.ExternalResource;

import com.vaadin.server.FontAwesome;

 */

public class RegistrationItemNameAndTypeButtons extends CompositeStyledComponent {

    private static final String DEFAULT_BUTTON_STYLES = "";

import java.util.Arrays;

import com.vaadin.annotations.AutoGenerated;

import com.vaadin.data.Validator.EmptyValueException;

/**

 * @author cmathew

 * @since 2 Apr 2015

 */

public class NewTaxonBaseComposite extends CustomComponent implements INewTaxonBaseComposite {

    /*- VaadinEditorProperties={"grid":"RegularGrid,20","showGrid":true,"snapToGrid":true,"snapToObject":true,"movingGuides":false,"snappingDistance":10} */

    @AutoGenerated

    private final Window dialog;

    private final IdUuidName accTaxonIun;

    private final IdUuidName classificationIun;

    private static final String CHOOSE_SECUNDUM_PROMPT = "Choose Secundum ....";

    /**

import java.util.Arrays;

import java.util.UUID;

import org.vaadin.peter.contextmenu.ContextMenu;

import org.vaadin.peter.contextmenu.ContextMenu.ContextMenuItem;

import org.vaadin.peter.contextmenu.ContextMenu.ContextMenuItemClickEvent;

/**

 * @author cmathew

 * @since 11 Mar 2015

 */

public class StatusComposite extends CustomComponent implements View, IStatusComposite, ICdmChangeListener {

    /*- VaadinEditorProperties={"grid":"RegularGrid,20","showGrid":true,"snapToGrid":true,"snapToObject":true,"movingGuides":false,"snappingDistance":10} */

    private GridLayout mainLayout;

    @AutoGenerated

    private Label inViewLabel;

    private Label filterLabel;

    @AutoGenerated

    private ComboBox classificationComboBox;

    private StatusComponentListener listener;

    private TreeTable mainTaxaTreeTable, excludedTaxaTreeTable;

import java.sql.SQLException;

import java.util.UUID;

import com.vaadin.data.Property;

import com.vaadin.data.util.sqlcontainer.SQLContainer;

    private static final long serialVersionUID = 2828992538007070061L;

    private DatabaseMetaData databaseMetaData;

import java.util.Map;

import java.util.Set;

import com.vaadin.data.Container;

import com.vaadin.data.Item;

import com.vaadin.data.Property;

/**

 * @author cmathew

 * @since 10 Mar 2015

 */

public class LeafNodeTaxonContainer extends CdmSQLContainer implements Container.Hierarchical  {

    public static final String NAME_ID = "NAME";

    public static final String ACCTAXON_ID = "ACCTAXON";

import java.lang.reflect.Method;

import java.util.Optional;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.annotation.Profile;

import org.springframework.stereotype.Component;

/**

 * @author a.kohlbecker

 * @since Jan 22, 2018

 */

@Component

@UIScope

@Profile("debug")

public class EntityCacheDebugger implements ViewChangeListener, EventBusListener<PopEditorOpenedEvent> {

    private UIEventBus uiEventBus;

        if(view != null){

                try {

                    Method getPresenterMethod = AbstractView.class.getDeclaredMethod("getPresenter");

                    getPresenterMethod.setAccessible(true);

                    if(CachingPresenter.class.isAssignableFrom(presenter.getClass())){

                        open(view, (CachingPresenter)presenter);

                    } else {

   }

    private void open(AbstractView view, CachingPresenter presenter) {

        EntityCacheDebuggerComponent content = new EntityCacheDebuggerComponent(presenter);

import org.apache.commons.beanutils.BeanUtilsBean;

import org.apache.commons.lang3.StringUtils;

import com.vaadin.ui.Component;

/**

 * @author a.kohlbecker

 * @since Oct 29, 2018

 */

public class EditorActionContextFormatter {

    private static final String NEW = "New";

import java.util.ArrayList;

import java.util.List;

import com.vaadin.event.ListenerMethod;

import com.vaadin.server.ErrorEvent;

    private static final long serialVersionUID = 3378605204517477112L;

    List<ErrorTypeHandler<? extends Throwable>> handlers = new ArrayList<>();

    public <E extends Throwable> void  registerHandler(ErrorTypeHandler<E> handler) {

    private <E extends Throwable> boolean delegate(ErrorEvent event, E throwable){

        Class<E> errorClass = (Class<E>) throwable.getClass();

        ErrorTypeHandler<E> handler = findHandler(errorClass);

        if(handler != null){

            handler.handleError(event, throwable);

import java.util.Set;

import java.util.UUID;

import org.json.JSONArray;

import org.json.JSONException;

import org.json.JSONObject;

/**

 * @author cmathew

 * @since 8 Apr 2015

 */

@StyleSheet({"css/d3.conceptrelationshiptree.css"})

@JavaScript({"extlib/d3.min.js", "lib/d3.conceptrelationshiptree_connector.js"})

public class D3ConceptRelationshipTree extends AbstractJavaScriptComponent {

    public enum Mode {

        OneToOne,

import java.io.Serializable;

import com.vaadin.navigator.View;

import com.vaadin.spring.access.ViewInstanceAccessControl;

    private static final long serialVersionUID = -5192116600545639108L;

    @Override

    public boolean isAccessGranted(UI ui, String beanName, View view) {

import java.io.Serializable;

import org.springframework.security.authentication.AnonymousAuthenticationToken;

import org.springframework.security.core.Authentication;

import org.springframework.security.core.context.SecurityContext;

    private static final long serialVersionUID = -4232241572782673248L;

    @Override

    public boolean isAccessGranted(UI ui, String beanName, View view) {

package eu.etaxonomy.cdm.vaadin.ui;

import org.springframework.beans.factory.annotation.Autowired;

import org.vaadin.spring.events.EventBus.UIEventBus;

    private static final long serialVersionUID = 7430086500775997281L;

    abstract protected ViewDisplay getViewDisplay();

package eu.etaxonomy.cdm.vaadin.ui;

import com.vaadin.annotations.Theme;

import com.vaadin.annotations.Widgetset;

@Widgetset("eu.etaxonomy.cdm.vaadin.AppWidgetSet")

public class ConceptRelationshipUI extends AbstractAuthenticatedUI {

    public static final String NAME = "concept";

    private static final String FIRST_VIEW = "editcr";

    @Override

    protected void doInit(VaadinRequest request) {

package eu.etaxonomy.cdm.vaadin.ui;

import com.vaadin.annotations.Theme;

import com.vaadin.annotations.Widgetset;

@Widgetset("eu.etaxonomy.cdm.vaadin.AppWidgetSet")

public class ConceptRelationshipUIRedirect extends AbstractAuthenticatedUI {

    private static final String FIRST_VIEW = "editcr";

    @Override

    protected void doInit(VaadinRequest request) {

package eu.etaxonomy.cdm.vaadin.ui;

import org.springframework.beans.factory.annotation.Autowired;

import org.vaadin.spring.events.EventBus.UIEventBus;

@SuppressWarnings("serial")

public class DistributionStatusUI extends UI{

    public static final String NAME = "distribution";

    private ViewDisplay viewDisplay;

import java.util.HashMap;

import java.util.Map;

import org.springframework.security.core.Authentication;

import org.springframework.security.core.context.SecurityContextHolder;

 */

public class CdmVaadinAuthentication {

    public static final String KEY = "key_authentication";

import java.util.Date;

import java.util.List;

import com.vaadin.server.Page;

import com.vaadin.ui.Notification;

import com.vaadin.ui.Notification.Type;

/**

 * @author cmathew

 * @since 14 Apr 2015

 */

public abstract class CdmVaadinOperation implements Runnable {

    private int pollInterval = -1;

    private CdmProgressComponent progressComponent;

import java.util.concurrent.locks.Lock;

import com.vaadin.server.VaadinSession;

import eu.etaxonomy.cdm.vaadin.session.BasicEventService;

/**

 * @author cmathew

 * @since 7 Apr 2015

 */

public class CdmVaadinSessionUtilities {

    public static void setCurrentAttribute(String name, Object value) {

        Lock sessionLock = VaadinSession.getCurrent().getLockInstance();

        try {

import java.sql.SQLException;

import java.util.Locale;

/**

 *

 * The methods correctCase and isEscaped have been inspired from the

 */

public class SQLUtils {

    public static String correctCase(final String databaseIdentifier, DatabaseMetaData databaseMetaData) throws SQLException

    {

        String resultIdentifier = databaseIdentifier;

import java.text.ParseException;

import java.util.Locale;

import com.vaadin.data.Validator;

import com.vaadin.data.util.converter.Converter;

                return Point.parseLatitude(value);

            }

        } catch (ParseException e) {

            throw new ConversionException(e);

        }

    }

import javax.mail.internet.AddressException;

import org.apache.commons.lang.StringUtils;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.core.env.Environment;

    private static final long serialVersionUID = 4020699735656994791L;

    private final static String PROPNAME_USER = "cdm-vaadin.login.usr";

        try {

            Authentication authentication = authenticationManager.authenticate(token);

            if(authentication != null && authentication.isAuthenticated()) {

                currentSecurityContext().setAuthentication(authentication);

                if(NavigationManager.class.isAssignableFrom(getNavigationManager().getClass())){

                    uiEventBus.publish(this, new AuthenticationSuccessEvent(userName));

                    uiEventBus.publish(this, new NavigationEvent(redirectToState));

                }

            }

        // attempt to auto login

        if(StringUtils.isNotEmpty(System.getProperty(PROPNAME_USER)) && StringUtils.isNotEmpty(System.getProperty(PROPNAME_PASSWORD))){

            authenticate(System.getProperty(PROPNAME_USER), System.getProperty(PROPNAME_PASSWORD));

        }

        if(getView()!= null){

            authenticate(event.getPayload().getUserName(), getView().getLoginDialog().getPassword().getValue());

        } else {

        }

    }

import java.util.List;

import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.security.core.GrantedAuthority;

import org.vaadin.addons.lazyquerycontainer.LazyQueryContainer;

 *

 * @author freimeier

 * @since 18.10.2017

 */

@ViewScope

@SpringView(name=DistributionTableViewBean.NAME)

public class DistributionTableViewBean extends AbstractPageView<DistributionTablePresenter>

            implements IDistributionTableView, AccessRestrictedView {

    public static final String NAME = "distGrid"; //$NON-NLS-1$

    @Autowired

import java.util.UUID;

import java.util.stream.Collectors;

import org.hibernate.criterion.Restrictions;

import org.springframework.context.annotation.Scope;

import org.vaadin.spring.events.annotation.EventBusListenerMethod;

/**

 * @author a.kohlbecker

 * @since Jan 26, 2018

 */

@SpringComponent

@Scope("prototype")

    private static final long serialVersionUID = 896305051895903033L;

    private HashSet<TaxonName> typifiedNamesAsLoaded;

import java.util.Stack;

import java.util.stream.Collectors;

import org.hibernate.criterion.Restrictions;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.annotation.Scope;

    private static final long serialVersionUID = 4255636253714476918L;

    private static final EnumSet<CRUD> COLLECTION_EDITOR_CRUD = EnumSet.of(CRUD.UPDATE, CRUD.DELETE);

import java.util.UUID;

import org.apache.commons.lang.StringUtils;

import org.hibernate.criterion.Restrictions;

import org.springframework.context.annotation.Scope;

import org.vaadin.spring.events.annotation.EventBusListenerMethod;

/**

 * @author a.kohlbecker

 * @since May 22, 2017

 */

@SpringComponent

@Scope("prototype")

    private static final long serialVersionUID = -3538980627079389221L;

    private static final EnumSet<CRUD> SUB_EDITOR_CRUD = EnumSet.of(CRUD.UPDATE, CRUD.DELETE);

    private static final List<String> RELATED_NAME_INIT_STRATEGY = Arrays.asList("$", "nomenclaturalSource.annotations",

    public static List<String> REFERENCE_INIT_STRATEGY = ReferenceEllypsisFormatter.INIT_STRATEGY;

    private CdmFilterablePagingProvider<Reference, Reference> nomReferencePagingProvider;

    private Reference publishedUnit;

import java.util.UUID;

import org.apache.commons.lang3.BooleanUtils;

import org.springframework.context.annotation.Scope;

import org.vaadin.viritin.fields.AbstractElementCollection.Instantiator;

import org.vaadin.viritin.fields.ElementCollectionField;

    private static final long serialVersionUID = -7037436241474466359L;

    private final static int GRID_COLS = 4;

    private final static int GRID_ROWS = 21;

import java.util.List;

import java.util.UUID;

import org.springframework.context.annotation.Scope;

import org.vaadin.spring.events.annotation.EventBusListenerMethod;

import org.vaadin.viritin.fields.CaptionGenerator;

/**

 * @author a.kohlbecker

 * @since Apr 5, 2017

 */

@SpringComponent

@Scope("prototype")

    private static final long serialVersionUID = -7926116447719010837L;

    ReferencePopupEditor inReferencePopup = null;

    CdmFilterablePagingProvider<Reference, Reference> inReferencePagingProvider;

    }

    @Override

    public void handleViewEntered() {

        super.handleViewEntered();

                AnnotationType.EDITORIAL().getUuid(), AnnotationType.TECHNICAL().getUuid()));

    }

    public void updateInReferencePageProvider() {

        inReferencePagingProvider = pagingProviderFactory.inReferencePagingProvider((ReferenceType) getView().getTypeSelect().getValue(), false);

        getView().getInReferenceCombobox().loadFrom(inReferencePagingProvider, inReferencePagingProvider, inReferencePagingProvider.getPageSize());

    }

    protected static BeanInstantiator<Reference> defaultBeanInstantiator = new BeanInstantiator<Reference>() {

        @Override

import java.util.Map;

import java.util.Set;

import org.springframework.context.annotation.Scope;

import com.vaadin.spring.annotation.SpringComponent;

    private static final long serialVersionUID = -4347633563800758815L;

    private TextField titleField;

import java.util.UUID;

import org.apache.commons.lang3.StringUtils;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.security.core.Authentication;

import org.vaadin.spring.events.EventScope;

@ViewScope

public class ListPresenter extends AbstractPresenter<ListView> {

    private static final String REGISTRATION_LIST_PRESENTER_SEARCH_FILTER = "registration.listPresenter.searchFilter";

    private static final EnumSet<RegistrationStatus> inProgressStatus = EnumSet.of(

import java.util.Stack;

import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;

import org.vaadin.spring.events.EventScope;

import org.vaadin.spring.events.annotation.EventBusListenerMethod;

/**

 * @author a.kohlbecker

 * @since Mar 3, 2017

 */

@SpringComponent

@ViewScope

public class RegistrationWorkingsetPresenter extends AbstractPresenter<RegistrationWorkingsetView> implements CachingPresenter {

    @Autowired

    private IRegistrationWorkingSetService regWorkingSetService;

import java.util.UUID;

import java.util.stream.Collectors;

import org.hibernate.criterion.Criterion;

import org.hibernate.criterion.Restrictions;

import org.joda.time.DateTime;

    private static final long serialVersionUID = 2283189121081612574L;

    private ReferencePopupEditor newReferencePopup;

    private Reference newReference;

        super();

    }

    @Override

    public void handleViewEntered() {

        getView().getReferenceCombobox().loadFrom(referencePagingProvider, referencePagingProvider, referencePagingProvider.getPageSize());

    }

    public void updateReferenceSearchMode(MatchMode value) {

        if(referencePagingProvider != null && value != null){

            referencePagingProvider.setMatchMode(value);

        }

    }

    @Override

    public void handleViewExit() {

        if(!registrationInProgress && newReference != null){

import java.util.Optional;

import java.util.Set;

import com.vaadin.data.Property;

import com.vaadin.data.Validator;

import eu.etaxonomy.vaadin.event.EditorActionType;

import eu.etaxonomy.vaadin.event.EntityEditorActionEvent;

import eu.etaxonomy.vaadin.event.EntityEditorActionListener;

import eu.etaxonomy.vaadin.permission.EditPermissionTester;

/**

    private static final long serialVersionUID = 4670707714503199599L;

    protected Class<F> fieldType;

import java.util.Set;

import java.util.Stack;

import org.vaadin.spring.events.EventScope;

import com.vaadin.data.Validator.InvalidValueException;

import com.vaadin.ui.VerticalLayout;

import com.vaadin.ui.themes.ValoTheme;

import eu.etaxonomy.cdm.database.PermissionDeniedException;

import eu.etaxonomy.cdm.vaadin.component.TextFieldNFix;

import eu.etaxonomy.cdm.vaadin.component.dialog.ContinueAlternativeCancelDialog;

public abstract class AbstractPopupEditor<DTO extends Object, P extends AbstractEditorPresenter<DTO, ? extends ApplicationView>>

    extends AbstractPopupView<P> {

    private BeanFieldGroup<DTO> fieldGroup;

        if(propertyId == null){

            // not found in the editor field group. Maybe the field is bound to a nested fieldgroup?

            // 1. find the NestedFieldGroup implementations from the field up to the editor

            PropertyIdPath nestedPropertyIds = new PropertyIdPath();

            Field parentField = field;

            HasComponents parentComponent = parentField.getParent();

import java.io.Serializable;

import java.util.Stack;

import org.springframework.beans.factory.DisposableBean;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import eu.etaxonomy.cdm.vaadin.event.EditorActionContext;

import eu.etaxonomy.cdm.vaadin.event.EntityChangeEvent;

import eu.etaxonomy.vaadin.ui.navigation.NavigationManager;

import eu.etaxonomy.vaadin.ui.view.DoneWithPopupEvent;

import eu.etaxonomy.vaadin.ui.view.PopupView;

 */

public abstract class AbstractPresenter<V extends ApplicationView> implements Serializable, DisposableBean {

    private static final long serialVersionUID = 5260910510283481832L;

	private V view;

	protected V getView() {

	    if(view == null){

        }

		return view;

	}

import javax.annotation.PostConstruct;

import org.springframework.beans.BeansException;

import org.springframework.beans.factory.DisposableBean;

import org.springframework.beans.factory.annotation.Autowired;

public abstract class AbstractView<P extends AbstractPresenter> extends CustomComponent

		implements ApplicationContextAware, ReleasableResourcesView, DisposableBean {

	private P presenter;

	@SuppressWarnings("unchecked")

    @PostConstruct

	protected final void init() {

		if(!ApplicationView.class.isAssignableFrom(this.getClass())){

		    throw new RuntimeException("Any view bean must implement the ApplicationView interface: ViewBean ---> ViewInterface ---> ApplicationView");

		}

        getPresenter().onViewExit();

    }

    @Override

    public void destroy() throws Exception {

       if(presenter != null){

import java.util.HashSet;

import java.util.UUID;

import org.hibernate.HibernateException;

import org.springframework.beans.factory.annotation.Autowired;

    private static final long serialVersionUID = 2218185546277084261L;

    protected BeanInstantiator<DTO> beanInstantiator = null;