<vaadin.version>7.7.10</vaadin.version>
<vaadin-spring.version>1.2.0</vaadin-spring.version>
<vaadin.plugin.version>${vaadin.version}</vaadin.plugin.version>
+ <vaadin-spring-addon-eventbus.version>2.0.0.RELEASE</vaadin-spring-addon-eventbus.version>
<cdmlib.version>4.14.0-SNAPSHOT</cdmlib.version>
<unitils.version>3.4.2</unitils.version>
<!--
<artifactId>vaadin-spring</artifactId>
<version>${vaadin-spring.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.vaadin.spring.addons</groupId>
+ <artifactId>vaadin-spring-addon-eventbus</artifactId>
+ <version>${vaadin-spring-addon-eventbus.version}</version>
+ </dependency>
<dependency>
<groupId>com.vaadin</groupId>
<artifactId>vaadin-server</artifactId>
import org.springframework.context.annotation.FilterType;
import org.springframework.core.env.Environment;
import org.springframework.security.authentication.AuthenticationProvider;
+import org.vaadin.spring.events.annotation.EnableEventBus;
import com.vaadin.spring.annotation.EnableVaadin;
import com.vaadin.spring.annotation.SpringUI;
@EnableVaadin // this imports VaadinConfiguration
@EnableVaadinSpringNavigation // activate the NavigationManagerBean
@EnableAnnotationBasedAccessControl // enable annotation based per view access control
+@EnableEventBus // enable the vaadin spring event bus
public class CdmVaadinConfiguration implements ApplicationContextAware {
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.context.ApplicationEventPublisher;
-import org.springframework.context.event.EventListener;
+import org.vaadin.spring.events.EventBus;
+import org.vaadin.spring.events.annotation.EventBusListenerMethod;
import com.vaadin.server.FontAwesome;
import com.vaadin.server.ThemeResource;
*/
private static final long serialVersionUID = 5344340511582993289L;
+ private EventBus.UIEventBus uiEventBus;
+
@Autowired
- protected ApplicationEventPublisher eventBus;
+ private final void setViewEventBus(EventBus.UIEventBus viewEventBus){
+ this.uiEventBus = viewEventBus;
+ viewEventBus.subscribe(AuthenticationSuccessEvent.class);
+ }
@Autowired
@Qualifier("cdmRepository")
updateAuthenticationButtons();
}
- @EventListener
- public void onAuthenticationSuccessEvent(AuthenticationSuccessEvent event){
+ @EventBusListenerMethod
+ public void onAuthenticationSuccessEvent(org.vaadin.spring.events.Event<AuthenticationSuccessEvent> event){
boolean isInitialized = userButton != null;
// The RegistrationToolbar is being initialize even if not needed only because it is a EventListener
// which causes Spring to initialize it.
* @return
*/
private void performLogin() {
- eventBus.publishEvent(new NavigationEvent("login", navigationManager.getCurrentViewName())); //$NON-NLS-1$
+ uiEventBus.publish(this, new NavigationEvent("login", navigationManager.getCurrentViewName())); //$NON-NLS-1$
}
public Button getDetailButton() {
return detailButton;
}
+
}
import org.joda.time.DateTime;
import org.joda.time.format.ISODateTimeFormat;
+import org.vaadin.spring.events.EventScope;
import com.vaadin.server.ExternalResource;
import com.vaadin.server.FontAwesome;
private void publishEvent(Object event) {
- parentView.getEventBus().publishEvent(event);
+ if(event instanceof NavigationEvent){
+ parentView.getViewEventBus().publish(EventScope.UI, this, event);
+ } else {
+ parentView.getViewEventBus().publish(this, event);
+ }
}
/* ====== RegistrationItemDesign Getters ====== */
import org.apache.log4j.Logger;
import org.springframework.context.annotation.Profile;
-import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
+import org.vaadin.spring.events.Event;
+import org.vaadin.spring.events.EventBus;
+import org.vaadin.spring.events.EventBus.ViewEventBus;
+import org.vaadin.spring.events.EventBusListener;
import com.vaadin.event.ShortcutAction;
import com.vaadin.event.ShortcutListener;
import eu.etaxonomy.vaadin.mvp.AbstractPresenter;
import eu.etaxonomy.vaadin.mvp.AbstractView;
import eu.etaxonomy.vaadin.ui.view.PopEditorOpenedEvent;
+import eu.etaxonomy.vaadin.ui.view.PopupView;
/**
* @author a.kohlbecker
*/
@Component
@Profile("debug")
-public class EntityCacheDebugger implements ViewChangeListener {
+public class EntityCacheDebugger implements ViewChangeListener, EventBusListener<PopEditorOpenedEvent> {
Logger logger = Logger.getLogger(EntityCacheDebugger.class);
+ private ViewEventBus viewEventBus;
+
+
+ // @Autowired // FIXME autowiring fails, need to put in UI Scope?
+ protected final void setViewEventBus(EventBus.ViewEventBus viewEventBus){
+ this.viewEventBus = viewEventBus;
+ viewEventBus.subscribe(this);
+ }
EntityCacheDebuggerShortcutListener shortcutListener;
}
}
- @EventListener
- public void onPopEditorOpenedEvent(PopEditorOpenedEvent event){
- if(event.getPopupView() != null && event.getPopupView() instanceof AbstractCdmPopupEditor){
- findWindow(((AbstractCdmPopupEditor)event.getPopupView())).addShortcutListener(shortcutListener);
+ @Override
+ public void onEvent(Event<PopEditorOpenedEvent> event){
+ PopupView popupView = event.getPayload().getPopupView();
+ if(popupView != null && popupView instanceof AbstractCdmPopupEditor){
+ findWindow(((AbstractCdmPopupEditor)popupView)).addShortcutListener(shortcutListener);
}
}
--- /dev/null
+/**
+* Copyright (C) 2018 EDIT
+* European Distributed Institute of Taxonomy
+* http://www.e-taxonomy.eu
+*
+* The contents of this file are subject to the Mozilla Public License Version 1.1
+* See LICENSE.TXT at the top of this package for the full license terms.
+*/
+package eu.etaxonomy.cdm.vaadin.event;
+
+import org.vaadin.spring.events.Event;
+import org.vaadin.spring.events.EventBusListenerMethodFilter;
+
+import eu.etaxonomy.vaadin.event.EditorActionType;
+
+/**
+ * @author a.kohlbecker
+ * @since Jan 31, 2018
+ *
+ */
+public class EditorActionTypeFilter implements EventBusListenerMethodFilter {
+
+ EditorActionType action;
+
+ private EditorActionTypeFilter(EditorActionType action) {
+ this.action = action;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean filter(Event<?> event) {
+ if (event.getPayload() instanceof AbstractEditorAction) {
+ AbstractEditorAction editorAction = (AbstractEditorAction) event.getPayload();
+ return this.action.equals(editorAction.type);
+ }
+ return false;
+ }
+
+ public static class Add extends EditorActionTypeFilter {
+
+ public Add() {
+ super(EditorActionType.ADD);
+ }
+
+ }
+
+ public static class Edit extends EditorActionTypeFilter {
+
+ public Edit() {
+ super(EditorActionType.EDIT);
+ }
+
+ }
+
+ public static class Remove extends EditorActionTypeFilter {
+
+ public Remove() {
+ super(EditorActionType.REMOVE);
+ }
+
+ }
+
+}
--- /dev/null
+/**
+* Copyright (C) 2018 EDIT
+* European Distributed Institute of Taxonomy
+* http://www.e-taxonomy.eu
+*
+* The contents of this file are subject to the Mozilla Public License Version 1.1
+* See LICENSE.TXT at the top of this package for the full license terms.
+*/
+package eu.etaxonomy.cdm.vaadin.event;
+
+import java.util.Optional;
+
+import org.vaadin.spring.events.Event;
+import org.vaadin.spring.events.EventBusListenerMethodFilter;
+
+import eu.etaxonomy.cdm.vaadin.event.EntityChangeEvent.Type;
+
+/**
+ * @author a.kohlbecker
+ * @since Jan 31, 2018
+ *
+ */
+public class EntityChangeEventFilter implements EventBusListenerMethodFilter {
+
+
+ private Optional<Class<?>> entityType = null;
+
+ private Optional<Type> eventType = null;
+
+ private EntityChangeEventFilter(Class<?> entityType, Type eventType){
+ this.entityType = Optional.of(entityType);
+ this.eventType = Optional.of(eventType);
+ }
+
+ private EntityChangeEventFilter(Type eventType){
+ this.eventType = Optional.of(eventType);
+ }
+
+ private EntityChangeEventFilter(Class<?> entityType){
+ this.entityType = Optional.of(entityType);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean filter(Event<?> event) {
+ if(event.getPayload() instanceof EntityChangeEvent){
+ EntityChangeEvent testEvent = (EntityChangeEvent)event.getPayload();
+ boolean match = true;
+ if(this.entityType != null){
+ match &= this.entityType.get().equals(testEvent.getEntityType());
+ }
+ if(this.eventType != null){
+ match &= this.eventType.get().equals(testEvent.getType());
+ }
+ return match;
+ }
+ return false;
+ }
+
+
+ public static class OccurrenceCollectionFilter extends EntityChangeEventFilter{
+
+ OccurrenceCollectionFilter(){
+ super(eu.etaxonomy.cdm.model.occurrence.Collection.class);
+ }
+ }
+
+ public static class ReferenceFilter extends EntityChangeEventFilter {
+
+ public ReferenceFilter() {
+ super(eu.etaxonomy.cdm.model.reference.Reference.class);
+ }
+ }
+
+}
--- /dev/null
+/**
+* Copyright (C) 2018 EDIT
+* European Distributed Institute of Taxonomy
+* http://www.e-taxonomy.eu
+*
+* The contents of this file are subject to the Mozilla Public License Version 1.1
+* See LICENSE.TXT at the top of this package for the full license terms.
+*/
+package eu.etaxonomy.cdm.vaadin.event;
+
+import org.vaadin.spring.events.Event;
+import org.vaadin.spring.events.EventBusListenerMethodFilter;
+
+/**
+ * @author a.kohlbecker
+ * @since Jan 31, 2018
+ *
+ */
+public class ShowDetailsEventEntityTypeFilter implements EventBusListenerMethodFilter {
+
+
+ Class entityType;
+
+ private ShowDetailsEventEntityTypeFilter(Class entityType){
+ this.entityType = entityType;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean filter(Event<?> event) {
+
+ if(event.getPayload() instanceof ShowDetailsEvent){
+ ShowDetailsEvent detailsEvent = (ShowDetailsEvent)event.getPayload();
+ return this.entityType.equals(detailsEvent.getEntityType());
+ }
+ return false;
+ }
+
+ public static class RegistrationWorkingSet extends ShowDetailsEventEntityTypeFilter{
+
+ public RegistrationWorkingSet(){
+ super(RegistrationWorkingSet.class);
+ }
+ }
+
+ public static class RegistrationDTO extends ShowDetailsEventEntityTypeFilter{
+
+ public RegistrationDTO(){
+ super(RegistrationDTO.class);
+ }
+ }
+}
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.context.ApplicationEventPublisher;
-import org.springframework.context.event.EventListener;
+import org.vaadin.spring.events.EventBus;
+import org.vaadin.spring.events.EventBus.UIEventBus;
+import org.vaadin.spring.events.EventBusListener;
import com.vaadin.server.FontAwesome;
import com.vaadin.spring.annotation.SpringComponent;
*/
@SpringComponent("registrationToolbar")
@UIScope
-public class RegistrationToolbar extends HorizontalLayout implements Toolbar {
+public class RegistrationToolbar extends HorizontalLayout implements Toolbar, EventBusListener<AuthenticationSuccessEvent> {
private static final long serialVersionUID = 2594781255088231474L;
- @Autowired
- protected ApplicationEventPublisher eventBus;
-
@Autowired
@Qualifier("cdmRepository")
private CdmRepository repo;
+ private UIEventBus uiEventBus;
+
+ @Autowired
+ protected final void setUIEventBus(EventBus.UIEventBus uiEventBus){
+ this.uiEventBus = uiEventBus;
+ uiEventBus.subscribe(this);
+ }
+
@Autowired
protected NavigationManager navigationManager;
}
- @EventListener
- public void onAuthenticationSuccessEvent(AuthenticationSuccessEvent event){
- boolean isInitialized = userButton != null;
- // The RegistrationToolbar is being initialize even if not needed only because it is a EventListener
- // which causes Spring to initialize it.
- // TODO After switching to an other event bus this check can be removed
- if(isInitialized){
- updateAuthenticationButtons();
- }
+ @Override
+ public void onEvent(org.vaadin.spring.events.Event<AuthenticationSuccessEvent> event) {
+ updateAuthenticationButtons();
}
/**
* @return
*/
private void performLogin() {
- eventBus.publishEvent(new NavigationEvent("login", navigationManager.getCurrentViewName()));
+ uiEventBus.publish(this, new NavigationEvent("login", navigationManager.getCurrentViewName()));
}
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.ApplicationEventPublisher;
+import org.vaadin.spring.events.EventBus.UIEventBus;
import com.vaadin.annotations.Theme;
import com.vaadin.annotations.Title;
// private Toolbar toolbar;
@Autowired
- ApplicationEventPublisher eventBus;
+ UIEventBus uiEventBus;
public DistributionStatusUI() {
// ((ToolbarDisplay)viewDisplay).setToolbar(toolbar);
// }
- eventBus.publishEvent(new UIInitializedEvent());
+ uiEventBus.publish(this, new UIInitializedEvent());
navigator.setDefaultViewName(INITIAL_VIEW);
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.context.ApplicationEventPublisher;
+import org.vaadin.spring.events.EventBus.UIEventBus;
import com.flowingcode.vaadin.addons.errorwindow.WindowErrorHandler;
import com.vaadin.annotations.Theme;
@Autowired(required = false)
EntityCacheDebugger entityCacheDebugger = null;
+ @Autowired
+ UIEventBus uiEventBus;
+
+ /*
+ * this HACKY solution forces the bean to be instantiated, TODO do it properly
+ */
+ // @Autowired
+ // MenuBeanDiscoveryBean bean;
+
+ @Autowired
+ private MainMenu mainMenu;
+
+ /*
+ * this HACKY solution forces the bean to be instantiated, TODO do it properly
+ */
+ // @Autowired
+ // MenuBeanDiscoveryBean bean;
+
+ @Autowired
+ @Qualifier("registrationToolbar")
+ private Toolbar toolbar;
+
+ //---------------------------------------------
+
+ public static final String INITIAL_VIEW = DashBoardView.NAME;
+
protected void configureAccessDeniedView() {
viewProvider.setAccessDeniedViewClass(RedirectToLoginView.class);
}
//---------------------------------------------
- public static final String INITIAL_VIEW = DashBoardView.NAME;
+
/*
// @Autowired
// MenuBeanDiscoveryBean bean;
- @Autowired
- private MainMenu mainMenu;
-
- @Autowired
- @Qualifier("registrationToolbar")
- private Toolbar toolbar;
-
- @Autowired
- ApplicationEventPublisher eventBus;
-
public RegistrationUI() {
}
}
- eventBus.publishEvent(new UIInitializedEvent());
+ uiEventBus.publish(this, new UIInitializedEvent());
String brand = "phycobank";
//TODO create annotation:
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.ApplicationEventPublisher;
-import org.springframework.context.event.EventListener;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
+import org.vaadin.spring.events.Event;
+import org.vaadin.spring.events.EventBus;
+import org.vaadin.spring.events.EventBus.ViewEventBus;
+import org.vaadin.spring.events.EventBusListener;
import com.vaadin.spring.annotation.SpringComponent;
import com.vaadin.spring.annotation.ViewScope;
*/
@SpringComponent
@ViewScope
-public class LoginPresenter extends AbstractPresenter<LoginView> {
+public class LoginPresenter extends AbstractPresenter<LoginView> implements EventBusListener<AuthenticationAttemptEvent> {
private static final long serialVersionUID = 4020699735656994791L;
private final static String PROPNAME_PASSWORD = "cdm-vaadin.login.pwd";
- @Autowired
- protected ApplicationEventPublisher eventBus;
-
private String redirectToState;
+ protected EventBus.UIEventBus uiEventBus;
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ protected void eventViewBusSubscription(ViewEventBus viewEventBus) {
+ // not listening to view scope events
+ }
+
+ @Autowired
+ protected void setUIEventBus(EventBus.UIEventBus uiEventBus){
+ this.uiEventBus = uiEventBus;
+ uiEventBus.subscribe(this);
+ }
+
public boolean authenticate(String userName, String password) {
getView().clearMessage();
log.debug("user '" + userName + "' authenticated");
currentSecurityContext().setAuthentication(authentication);
if(NavigationManager.class.isAssignableFrom(getNavigationManager().getClass())){
- eventBus.publishEvent(new AuthenticationSuccessEvent(userName));
+ uiEventBus.publish(this, new AuthenticationSuccessEvent(userName));
log.debug("redirecting to " + redirectToState);
- eventBus.publishEvent(new NavigationEvent(redirectToState));
+ uiEventBus.publish(this, new NavigationEvent(redirectToState));
}
}
} catch (AuthenticationException e){
}
}
- @EventListener
- protected void onLoginEvent(AuthenticationAttemptEvent e){
- authenticate(e.getUserName(), getView().getLoginDialog().getPassword().getValue());
+ @Override
+ public void onEvent(Event<AuthenticationAttemptEvent> event) {
+ authenticate(event.getPayload().getUserName(), getView().getLoginDialog().getPassword().getValue());
}
-
}
*/
package eu.etaxonomy.cdm.vaadin.view;
+import org.vaadin.spring.events.EventScope;
+
import com.vaadin.navigator.View;
import com.vaadin.navigator.ViewChangeListener.ViewChangeEvent;
import com.vaadin.spring.annotation.SpringView;
setCompositionRoot(root);
loginDialog.getLoginButton().addClickListener(e -> handleLoginClick(e));
- loginDialog.getRegisterButton().addClickListener(e -> eventBus.publishEvent(new RegisterNewUserEvent(e)));
- loginDialog.getSendOnetimeLogin().addClickListener(e -> eventBus.publishEvent(new PasswordRevoveryEvent(e)));
+ loginDialog.getRegisterButton().addClickListener(e -> getViewEventBus().publish(EventScope.UI, this, new RegisterNewUserEvent(e)));
+ loginDialog.getSendOnetimeLogin().addClickListener(e -> getViewEventBus().publish(EventScope.UI, this, new PasswordRevoveryEvent(e)));
// NOTE: null viewName will be replaced by the default view name in NavigationManagerBean
- loginDialog.getCancelLoginButton().addClickListener(e -> eventBus.publishEvent(new NavigationEvent(null)));
- loginDialog.getCancelRegistrationButton().addClickListener(e -> eventBus.publishEvent(new NavigationEvent(null)));
+ loginDialog.getCancelLoginButton().addClickListener(e -> getViewEventBus().publish(EventScope.UI, this, new NavigationEvent(null)));
+ loginDialog.getCancelRegistrationButton().addClickListener(e -> getViewEventBus().publish(EventScope.UI, this, new NavigationEvent(null)));
}
/**
* @param e
*/
private void handleLoginClick(ClickEvent e) {
- eventBus.publishEvent(new AuthenticationAttemptEvent(e, loginDialog.getUserName().getValue()));
+ getViewEventBus().publish(this, new AuthenticationAttemptEvent(e, loginDialog.getUserName().getValue()));
}
@Override
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
-import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.annotation.Scope;
+import org.vaadin.spring.events.EventBus;
import com.vaadin.navigator.Navigator;
import com.vaadin.navigator.View;
NavigationManager navigationManager;
@Autowired
- protected ApplicationEventPublisher eventBus;
+ protected EventBus.UIEventBus uiEventBus;
public RedirectToLoginView() {
String currentState = ((Navigator)navigationManager).getState();
// redirect to the login view and pass over the current state
- eventBus.publishEvent(new NavigationEvent(LoginViewBean.NAME, currentState));
+ uiEventBus.publish(this, new NavigationEvent(LoginViewBean.NAME, currentState));
}
}
import org.vaadin.addons.lazyquerycontainer.LazyQueryContainer;
import org.vaadin.addons.lazyquerycontainer.QueryDefinition;
import org.vaadin.addons.lazyquerycontainer.QueryFactory;
+import org.vaadin.spring.events.EventBus.ViewEventBus;
import com.vaadin.server.VaadinSession;
import com.vaadin.spring.annotation.SpringComponent;
@Autowired
@Qualifier("cdmRepository")
- private CdmRepository repo;
+ private CdmRepository repo; // TODO remove, since this is already in the super class
- public int updateDistributionField(String distributionAreaString, Object comboValue, Taxon taxon) {
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ protected void eventViewBusSubscription(ViewEventBus viewEventBus) {
+ // no point subscribing
+ }
+
+ public int updateDistributionField(String distributionAreaString, Object comboValue, Taxon taxon) {
TransactionStatus tx = repo.startTransaction();
taxon = (Taxon)repo.getTaxonService().find(taxon.getUuid());
Set<DefinedTermBase> chosenTerms = getChosenTerms();
*/
package eu.etaxonomy.cdm.vaadin.view.name;
+import org.springframework.context.annotation.Scope;
+
+import com.vaadin.spring.annotation.SpringComponent;
import com.vaadin.ui.Alignment;
import com.vaadin.ui.CheckBox;
import com.vaadin.ui.GridLayout;
* @since Jan 26, 2018
*
*/
+@SpringComponent
+@Scope("prototype")
public class NameTypeDesignationPopupEditor extends AbstractCdmPopupEditor<NameTypeDesignation, NameTypeDesignationPresenter>
implements NameTypeDesignationEditorView {
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Scope;
+
+import com.vaadin.spring.annotation.SpringComponent;
import eu.etaxonomy.cdm.api.service.IService;
import eu.etaxonomy.cdm.model.name.NameTypeDesignation;
* @since Jan 26, 2018
*
*/
+@SpringComponent
+@Scope("prototype")
public class NameTypeDesignationPresenter
extends AbstractCdmEditorPresenter<NameTypeDesignation, NameTypeDesignationEditorView> {
import java.util.Set;
import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.event.EventListener;
+import org.springframework.context.annotation.Scope;
+import org.vaadin.spring.events.annotation.EventBusListenerMethod;
import org.vaadin.viritin.fields.AbstractElementCollection;
+import com.vaadin.spring.annotation.SpringComponent;
+
import eu.etaxonomy.cdm.api.service.IRegistrationService;
import eu.etaxonomy.cdm.cache.CdmTransientEntityCacher;
import eu.etaxonomy.cdm.model.ICdmCacher;
import eu.etaxonomy.cdm.vaadin.component.CdmBeanItemContainerFactory;
import eu.etaxonomy.cdm.vaadin.component.CollectionRowItemCollection;
import eu.etaxonomy.cdm.vaadin.event.EntityChangeEvent;
+import eu.etaxonomy.cdm.vaadin.event.EntityChangeEventFilter;
import eu.etaxonomy.cdm.vaadin.event.ToOneRelatedEntityButtonUpdater;
import eu.etaxonomy.cdm.vaadin.event.ToOneRelatedEntityReloader;
import eu.etaxonomy.cdm.vaadin.model.registration.RegistrationTermLists;
* @since Jun 13, 2017
*
*/
+@SpringComponent
+@Scope("prototype")
public class SpecimenTypeDesignationWorkingsetEditorPresenter
extends AbstractEditorPresenter<SpecimenTypeDesignationWorkingSetDTO , SpecimenTypeDesignationWorkingsetPopupEditorView>
implements CachingPresenter {
return store;
}
-
/**
* Loads an existing working set from the database. This process actually involves
* loading the Registration specified by the <code>RegistrationAndWorkingsetId.registrationId</code> and in
collectionPopupEditor.loadInEditor(collectionId);
}
- @EventListener(condition = "#event.entityType == T(eu.etaxonomy.cdm.model.occurrence.Collection)")
+
+ @EventBusListenerMethod(filter = EntityChangeEventFilter.OccurrenceCollectionFilter.class)
public void onCollectionEvent(EntityChangeEvent event){
- Collection newCollection = getRepo().getCollectionService().load(event.getEntityId(), Arrays.asList(new String[]{"$.institute"}));
+ Collection newCollection = getRepo().getCollectionService().load(
+ event.getEntityId(), Arrays.asList(new String[]{"$.institute"})
+ );
cache.load(newCollection);
for( CollectionRowItemCollection row : collectionPopuEditorSourceRows) {
referencePopupEditor.loadInEditor(referenceId);
}
- @EventListener(condition = "#event.entityType == T(eu.etaxonomy.cdm.model.reference.Reference)")
+ @EventBusListenerMethod(filter = EntityChangeEventFilter.ReferenceFilter.class)
public void onReferenceEvent(EntityChangeEvent event){
Reference newRef = getRepo().getReferenceService().load(event.getEntityId(), Arrays.asList(new String[]{"$"}));
import java.util.Collection;
import java.util.EnumSet;
+import org.springframework.context.annotation.Scope;
import org.springframework.security.core.GrantedAuthority;
import org.vaadin.viritin.fields.ElementCollectionField;
import com.vaadin.data.validator.DoubleRangeValidator;
+import com.vaadin.spring.annotation.SpringComponent;
import com.vaadin.ui.AbstractSelect.ItemCaptionMode;
import com.vaadin.ui.Component;
import com.vaadin.ui.GridLayout;
* @since May 15, 2017
*
*/
+@SpringComponent
+@Scope("prototype")
public class SpecimenTypeDesignationWorkingsetPopupEditor
extends AbstractPopupEditor<SpecimenTypeDesignationWorkingSetDTO, SpecimenTypeDesignationWorkingsetEditorPresenter>
implements SpecimenTypeDesignationWorkingsetPopupEditorView, AccessRestrictedView, PerEntityAuthorityGrantingEditor {
import org.apache.log4j.Logger;
import org.hibernate.criterion.Restrictions;
-import org.springframework.context.event.EventListener;
+import org.springframework.context.annotation.Scope;
+import org.vaadin.spring.events.annotation.EventBusListenerMethod;
+import com.vaadin.spring.annotation.SpringComponent;
import com.vaadin.ui.AbstractField;
import eu.etaxonomy.cdm.api.service.INameService;
import eu.etaxonomy.cdm.persistence.hibernate.permission.CRUD;
import eu.etaxonomy.cdm.service.CdmFilterablePagingProvider;
import eu.etaxonomy.cdm.vaadin.component.CdmBeanItemContainerFactory;
+import eu.etaxonomy.cdm.vaadin.event.EditorActionTypeFilter;
import eu.etaxonomy.cdm.vaadin.event.ReferenceEditorAction;
import eu.etaxonomy.cdm.vaadin.event.TaxonNameEditorAction;
import eu.etaxonomy.cdm.vaadin.event.ToOneRelatedEntityButtonUpdater;
* @since May 22, 2017
*
*/
+@SpringComponent
+@Scope("prototype")
public class TaxonNameEditorPresenter extends AbstractCdmEditorPresenter<TaxonName, TaxonNamePopupEditorView> {
/**
return getRepo().getNameService();
}
- @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).ADD")
+ @EventBusListenerMethod(filter = EditorActionTypeFilter.Add.class)
public void onReferenceEditorActionAdd(ReferenceEditorAction event) {
if(getView() == null || event.getSourceView() != getView() ){
return;
}
+
referenceEditorPopup = getNavigationManager().showInPopup(ReferencePopupEditor.class);
referenceEditorPopup.grantToCurrentUser(EnumSet.of(CRUD.UPDATE, CRUD.DELETE));
}
}
- @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).EDIT")
+ @EventBusListenerMethod(filter = EditorActionTypeFilter.Edit.class)
public void onReferenceEditorActionEdit(ReferenceEditorAction event) {
+
if(getView() == null || event.getSourceView() != getView() ){
return;
}
}
}
- @EventListener
+ @EventBusListenerMethod
public void onDoneWithPopupEvent(DoneWithPopupEvent event){
if(event.getPopup() == referenceEditorPopup){
}
}
- @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).EDIT")
+ @EventBusListenerMethod(filter = EditorActionTypeFilter.Edit.class)
public void onTaxonNameEditorActionEdit(TaxonNameEditorAction event) {
if(getView() == null || event.getSourceView() != getView() ){
return;
}
+
basionymSourceField = (AbstractField<TaxonName>)event.getSourceComponent();
basionymNamePopup = getNavigationManager().showInPopup(TaxonNamePopupEditor.class);
}
- @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).ADD")
+ @EventBusListenerMethod(filter = EditorActionTypeFilter.Add.class)
public void onReferenceEditorActionAdd(TaxonNameEditorAction event) {
if(getView() == null || event.getSourceView() != getView() ){
return;
}
+
basionymSourceField = (AbstractField<TaxonName>)event.getSourceComponent();
basionymNamePopup = getNavigationManager().showInPopup(TaxonNamePopupEditor.class);
import java.util.EnumSet;
import org.apache.commons.lang3.BooleanUtils;
+import org.springframework.context.annotation.Scope;
import org.springframework.security.core.GrantedAuthority;
import com.vaadin.shared.ui.label.ContentMode;
+import com.vaadin.spring.annotation.SpringComponent;
import com.vaadin.ui.Alignment;
import com.vaadin.ui.CheckBox;
import com.vaadin.ui.GridLayout;
* @since May 22, 2017
*
*/
+@SpringComponent
+@Scope("prototype")
public class TaxonNamePopupEditor extends AbstractCdmPopupEditor<TaxonName, TaxonNameEditorPresenter> implements TaxonNamePopupEditorView, AccessRestrictedView {
private static final long serialVersionUID = -7037436241474466359L;
row++;
nomReferenceCombobox = new ToOneRelatedEntityCombobox<Reference>("Nomenclatural reference", Reference.class);
- nomReferenceCombobox.addClickListenerAddEntity(e -> getEventBus().publishEvent(
+ nomReferenceCombobox.addClickListenerAddEntity(e -> getViewEventBus().publish(this,
new ReferenceEditorAction(EditorActionType.ADD, null, nomReferenceCombobox, this)
));
nomReferenceCombobox.addClickListenerEditEntity(e -> {
if(nomReferenceCombobox.getValue() != null){
- getEventBus().publishEvent(
+ getViewEventBus().publish(this,
new ReferenceEditorAction(
EditorActionType.EDIT,
nomReferenceCombobox.getValue().getId(),
beanId = ((CdmBase)fieldValue).getId();
}
- eventBus.publishEvent(new TaxonNameEditorAction(e.getAction(), beanId, e.getSource(), this));
+ getViewEventBus().publish(this, new TaxonNameEditorAction(e.getAction(), beanId, e.getSource(), this));
});
grid.setComponentAlignment(basionymsComboboxSelect, Alignment.TOP_RIGHT);
row++;
import java.util.Arrays;
import java.util.List;
-import org.springframework.context.event.EventListener;
+import org.springframework.context.annotation.Scope;
+import org.vaadin.spring.events.annotation.EventBusListenerMethod;
+
+import com.vaadin.spring.annotation.SpringComponent;
import eu.etaxonomy.cdm.api.service.IService;
import eu.etaxonomy.cdm.model.occurrence.Collection;
import eu.etaxonomy.cdm.service.CdmFilterablePagingProvider;
import eu.etaxonomy.cdm.vaadin.event.CollectionEditorAction;
+import eu.etaxonomy.cdm.vaadin.event.EditorActionTypeFilter;
import eu.etaxonomy.cdm.vaadin.event.ToOneRelatedEntityReloader;
import eu.etaxonomy.cdm.vaadin.security.UserHelper;
import eu.etaxonomy.vaadin.mvp.AbstractCdmEditorPresenter;
* @since Dec 21, 2017
*
*/
+@SpringComponent
+@Scope("prototype")
public class CollectionEditorPresenter extends AbstractCdmEditorPresenter<Collection, CollectionPopupEditorView> {
private static final long serialVersionUID = -1996365248431425021L;
private CollectionPopupEditor collectionPopuEditor;
+
/**
* {@inheritDoc}
*/
getView().getSuperCollectionCombobox().getSelect().addValueChangeListener(new ToOneRelatedEntityReloader<Collection>(getView().getSuperCollectionCombobox(),this));
}
- @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).ADD")
+ @EventBusListenerMethod(filter = EditorActionTypeFilter.Add.class)
public void onCollectionEditorActionAdd(CollectionEditorAction event) {
if(!checkFromOwnView(event)){
collectionPopuEditor.loadInEditor(null);
}
- @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).EDIT")
+ @EventBusListenerMethod(filter = EditorActionTypeFilter.Edit.class)
public void onCollectionEditorActionEdit(CollectionEditorAction event) {
if(!checkFromOwnView(event)){
collectionPopuEditor.loadInEditor(event.getEntityId());
}
+ @EventBusListenerMethod()
public void onDoneWithPopupEvent(DoneWithPopupEvent event){
if(event.getPopup() == collectionPopuEditor){
if(event.getReason() == Reason.SAVE){
*/
package eu.etaxonomy.cdm.vaadin.view.occurrence;
+import org.springframework.context.annotation.Scope;
import org.springframework.security.core.GrantedAuthority;
+import com.vaadin.spring.annotation.SpringComponent;
import com.vaadin.ui.GridLayout;
import com.vaadin.ui.TextField;
* @since Dec 21, 2017
*
*/
+@SpringComponent
+@Scope("prototype")
public class CollectionPopupEditor extends AbstractCdmPopupEditor<Collection, CollectionEditorPresenter> implements CollectionPopupEditorView, AccessRestrictedView {
private static final long serialVersionUID = 2019724189877425882L;
row++;
superCollectionCombobox = new ToOneRelatedEntityCombobox<Collection>("Super-collection", Collection.class);
- superCollectionCombobox.addClickListenerAddEntity(e -> getEventBus().publishEvent(
+ superCollectionCombobox.addClickListenerAddEntity(e -> getViewEventBus().publish(this,
new CollectionEditorAction(EditorActionType.ADD, null, superCollectionCombobox, this)
));
superCollectionCombobox.addClickListenerEditEntity(e -> {
if(superCollectionCombobox.getValue() != null){
- getEventBus().publishEvent(
+ getViewEventBus().publish(this,
new CollectionEditorAction(
EditorActionType.EDIT,
superCollectionCombobox.getValue().getId(),
new ToOneRelatedEntityButtonUpdater<Collection>(superCollectionCombobox)
);
- superCollectionCombobox.addClickListenerAddEntity( e -> getEventBus().publishEvent(
+ superCollectionCombobox.addClickListenerAddEntity( e -> getViewEventBus().publish(this,
new CollectionEditorAction(
EditorActionType.ADD,
null,
));
superCollectionCombobox.addClickListenerEditEntity(e -> {
if(superCollectionCombobox.getValue() != null){
- getEventBus().publishEvent(
+ getViewEventBus().publish(this,
new CollectionEditorAction(
EditorActionType.EDIT,
superCollectionCombobox.getValue().getId(),
import java.util.List;
import org.apache.log4j.Logger;
-import org.springframework.context.event.EventListener;
+import org.springframework.context.annotation.Scope;
+import org.vaadin.spring.events.annotation.EventBusListenerMethod;
import org.vaadin.viritin.fields.CaptionGenerator;
+import com.vaadin.spring.annotation.SpringComponent;
+
import eu.etaxonomy.cdm.api.service.IService;
import eu.etaxonomy.cdm.model.agent.AgentBase;
import eu.etaxonomy.cdm.model.agent.Person;
* @since Apr 5, 2017
*
*/
+@SpringComponent
+@Scope("prototype")
public class ReferenceEditorPresenter extends AbstractCdmEditorPresenter<Reference, ReferencePopupEditorView> {
private static final long serialVersionUID = -7926116447719010837L;
}
+
/**
* {@inheritDoc}
*/
* @param editorAction
* @throws EditorEntityBeanException
*/
- @EventListener(condition = "#editorAction.sourceComponent != null")
+ @EventBusListenerMethod
public void onReferenceEditorAction(ReferenceEditorAction editorAction) {
- if(!isFromOwnView(editorAction)){
+
+ if(!isFromOwnView(editorAction) || editorAction.getSourceComponent() == null){
return;
}
+
if(ToOneRelatedEntityField.class.isAssignableFrom(editorAction.getSourceComponent().getClass())){
if(editorAction.isAddAction()){
inReferencePopup = getNavigationManager().showInPopup(ReferencePopupEditor.class);
}
}
- @EventListener
+ @EventBusListenerMethod
public void doDoneWithPopupEvent(DoneWithPopupEvent event){
if(event.getPopup().equals(inReferencePopup)){
import java.util.Collection;
import java.util.EnumSet;
+import org.springframework.context.annotation.Scope;
import org.springframework.security.core.GrantedAuthority;
+import com.vaadin.spring.annotation.SpringComponent;
import com.vaadin.ui.Alignment;
import com.vaadin.ui.GridLayout;
import com.vaadin.ui.ListSelect;
* @since Apr 4, 2017
*
*/
+@SpringComponent
+@Scope("prototype")
public class ReferencePopupEditor extends AbstractCdmPopupEditor<Reference, ReferenceEditorPresenter> implements ReferencePopupEditorView, AccessRestrictedView {
private static final long serialVersionUID = -4347633563800758815L;
inReferenceCombobox = new ToOneRelatedEntityCombobox<Reference>("In-reference", Reference.class);
inReferenceCombobox.setWidth(100, Unit.PERCENTAGE);
- inReferenceCombobox.addClickListenerAddEntity(e -> getEventBus().publishEvent(
+ inReferenceCombobox.addClickListenerAddEntity(e -> getViewEventBus().publish(this,
new ReferenceEditorAction(EditorActionType.ADD, null, inReferenceCombobox, this)
));
inReferenceCombobox.addClickListenerEditEntity(e -> {
if(inReferenceCombobox.getValue() != null){
- getEventBus().publishEvent(
+ getViewEventBus().publish(this,
new ReferenceEditorAction(
EditorActionType.EDIT,
inReferenceCombobox.getValue().getId(),
package eu.etaxonomy.cdm.vaadin.view.registration;
import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.ApplicationEventPublisher;
+import org.vaadin.spring.events.EventBus;
import com.vaadin.navigator.View;
import com.vaadin.navigator.ViewChangeListener.ViewChangeEvent;
private static final long serialVersionUID = -6172448806905158782L;
@Autowired
- ApplicationEventPublisher eventBus;
+ protected EventBus.UIEventBus uiEventBus;
public DashBoardView() {
Responsive.makeResponsive(dashboard);
- buttonNew.addClickListener(e -> eventBus.publishEvent(new NavigationEvent(StartRegistrationViewBean.NAME)));
- buttonContinue.addClickListener(e -> eventBus.publishEvent(new NavigationEvent(ListViewBean.NAME + "/" + ListView.Mode.inProgress.name())));
- buttonList.addClickListener(e -> eventBus.publishEvent(new NavigationEvent(ListViewBean.NAME + "/" + ListViewBean.Mode.all.name())));
+ buttonNew.addClickListener(e -> uiEventBus.publish(this, new NavigationEvent(StartRegistrationViewBean.NAME)));
+ buttonContinue.addClickListener(e -> uiEventBus.publish(this, new NavigationEvent(ListViewBean.NAME + "/" + ListView.Mode.inProgress.name())));
+ buttonList.addClickListener(e -> uiEventBus.publish(this, new NavigationEvent(ListViewBean.NAME + "/" + ListViewBean.Mode.all.name())));
}
/**
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.event.EventListener;
import org.springframework.security.core.Authentication;
+import org.vaadin.spring.events.annotation.EventBusListenerMethod;
import com.vaadin.spring.annotation.SpringComponent;
import com.vaadin.spring.annotation.ViewScope;
return workingSetService;
}
+
@Override
public void handleViewEntered() {
return dtoPager;
}
- @EventListener(classes=ShowDetailsEvent.class, condition = "#event.type == T(eu.etaxonomy.cdm.vaadin.view.registration.RegistrationDTO)")
- public void onShowDetailsEvent(ShowDetailsEvent<?,?> event) { // WARNING don't use more specific generic type arguments
- RegistrationDTO regDto = getWorkingSetService().loadDtoById((Integer)event.getIdentifier());
- if(event.getProperty().equals("messages")){
- if(getView() != null){
- getView().openDetailsPopup("Messages", regDto.getMessages());
+ @EventBusListenerMethod
+ public void onShowDetailsEvent(ShowDetailsEvent<?,?> event) {
+
+ if(event.getEntityType().equals(RegistrationDTO.class)){
+ RegistrationDTO regDto = getWorkingSetService().loadDtoById((Integer)event.getIdentifier());
+ if(event.getProperty().equals("messages")){
+ if(getView() != null){
+ getView().openDetailsPopup("Messages", regDto.getMessages());
+ }
}
}
}
- @EventListener
+ @EventBusListenerMethod
public void onEntityChangeEvent(EntityChangeEvent event){
if(event.getEntityType().isAssignableFrom(Reference.class)){
// TODO update component showing the according reference, is there a Vaadin event supporting this?
}
}
- @EventListener
+ @EventBusListenerMethod
public void onUpdateResultsEvent(UpdateResultsEvent event){
getView().populate(pageRegistrations(event.getField(), event.getNewText()));
}
* @return
*/
private void updateResults(TextField field, String newText) {
- eventBus.publishEvent(new UpdateResultsEvent(field, newText, this));
+ getViewEventBus().publish(this, new UpdateResultsEvent(field, newText, this));
}
@Override
import java.util.Arrays;
import java.util.List;
+import org.springframework.context.annotation.Scope;
+
+import com.vaadin.spring.annotation.SpringComponent;
+
import eu.etaxonomy.cdm.api.service.IRegistrationService;
import eu.etaxonomy.cdm.model.agent.Institution;
import eu.etaxonomy.cdm.model.common.User;
* @since May 15, 2017
*
*/
+@SpringComponent
+@Scope("prototype")
public class RegistrationEditorPresenter extends AbstractCdmEditorPresenter<Registration, RegistrationPopEditorView> {
private static final long serialVersionUID = 6930557602995331944L;
import java.util.Arrays;
import java.util.Collection;
+import org.springframework.context.annotation.Scope;
import org.springframework.security.core.GrantedAuthority;
+import com.vaadin.spring.annotation.SpringComponent;
import com.vaadin.ui.DateField;
import com.vaadin.ui.FormLayout;
import com.vaadin.ui.ListSelect;
* @since May 15, 2017
*
*/
+@SpringComponent
+@Scope("prototype")
public class RegistrationPopupEditor extends AbstractCdmPopupEditor<Registration, RegistrationEditorPresenter>
implements RegistrationPopEditorView, AccessRestrictedView {
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.event.EventListener;
import org.springframework.security.core.Authentication;
import org.springframework.transaction.TransactionStatus;
+import org.vaadin.spring.events.annotation.EventBusListenerMethod;
import com.vaadin.spring.annotation.SpringComponent;
import com.vaadin.spring.annotation.ViewScope;
import eu.etaxonomy.cdm.service.CdmFilterablePagingProvider;
import eu.etaxonomy.cdm.service.CdmStore;
import eu.etaxonomy.cdm.service.IRegistrationWorkingSetService;
+import eu.etaxonomy.cdm.vaadin.event.EditorActionTypeFilter;
import eu.etaxonomy.cdm.vaadin.event.EntityChangeEvent;
import eu.etaxonomy.cdm.vaadin.event.ReferenceEditorAction;
import eu.etaxonomy.cdm.vaadin.event.RegistrationEditorAction;
import eu.etaxonomy.cdm.vaadin.event.ShowDetailsEvent;
+import eu.etaxonomy.cdm.vaadin.event.ShowDetailsEventEntityTypeFilter;
import eu.etaxonomy.cdm.vaadin.event.TaxonNameEditorAction;
import eu.etaxonomy.cdm.vaadin.event.TypeDesignationWorkingsetEditorAction;
import eu.etaxonomy.cdm.vaadin.event.registration.RegistrationWorkingsetAction;
public RegistrationWorkingsetPresenter() {
}
-
/**
* Always create a new Store
*
}
}
- @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).ADD")
+
+ @EventBusListenerMethod(filter = EditorActionTypeFilter.Add.class)
public void onReferenceEditorActionAdd(ReferenceEditorAction event) {
if(!checkFromOwnView(event)){
popup.loadInEditor(null);
}
- @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).EDIT")
+ @EventBusListenerMethod(filter = EditorActionTypeFilter.Edit.class)
public void onReferenceEditorActionEdit(ReferenceEditorAction event) {
if(!checkFromOwnView(event)){
popup.loadInEditor(event.getEntityId());
}
- @EventListener
+ @EventBusListenerMethod
public void onDoneWithReferencePopupEditor(DoneWithPopupEvent event) throws RegistrationValidationException{
if(event.getPopup() instanceof ReferencePopupEditor){
if(event.getReason().equals(Reason.SAVE)){
}
}
- @EventListener
+ @EventBusListenerMethod
public void onDoneWithSpecimenTypeDesignationWorkingsetPopupEditor(DoneWithPopupEvent event) throws RegistrationValidationException{
if(event.getPopup() instanceof SpecimenTypeDesignationWorkingsetPopupEditor){
if(event.getReason().equals(Reason.SAVE)){
}
}
- @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).EDIT")
+ @EventBusListenerMethod(filter = EditorActionTypeFilter.Edit.class)
public void onRegistrationEditorAction(RegistrationEditorAction event) {
if(!checkFromOwnView(event)){
popup.loadInEditor(event.getEntityId());
}
- @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).EDIT")
+ @EventBusListenerMethod(filter = EditorActionTypeFilter.Edit.class)
public void onTaxonNameEditorActionEdit(TaxonNameEditorAction event) {
if(!checkFromOwnView(event)){
}
- @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).ADD")
+ @EventBusListenerMethod(filter = EditorActionTypeFilter.Add.class)
public void onTaxonNameEditorActionAdd(TaxonNameEditorAction event) {
if(!checkFromOwnView(event)){
* @param event
* @throws RegistrationValidationException
*/
- @EventListener
+ @EventBusListenerMethod
public void onDoneWithTaxonnameEditor(DoneWithPopupEvent event) throws RegistrationValidationException{
if(event.getPopup() instanceof TaxonNamePopupEditor){
TransactionStatus txStatus = getRepo().startTransaction();
* @param event
* @throws RegistrationValidationException
*/
- @EventListener(condition = "#event.action == T(eu.etaxonomy.cdm.vaadin.event.registration.RegistrationWorkingsetAction.Action).start")
+ @EventBusListenerMethod
public void onRegistrationWorkflowEventActionStart(RegistrationWorkingsetAction event) throws RegistrationValidationException {
+ if(!event.isStart()){
+ return;
+ }
+
getView().getAddExistingNameCombobox().commit();
TaxonName typifiedName = getView().getAddExistingNameCombobox().getValue();
if(typifiedName != null){
}
- @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).EDIT")
+
+ @EventBusListenerMethod(filter = EditorActionTypeFilter.Edit.class)
public void onTypeDesignationsEditorActionEdit(TypeDesignationWorkingsetEditorAction event) {
if(!checkFromOwnView(event)){
}
}
- @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).ADD && #event.sourceComponent == null")
+ @EventBusListenerMethod(filter = EditorActionTypeFilter.Add.class)
public void onAddNewTypeDesignationWorkingset(TypeDesignationWorkingsetEditorAction event) {
+ if(event.getSourceComponent() != null){
+ return;
+ }
+
if(event.getWorkingSetType() == TypeDesignationWorkingSetType.SPECIMEN_TYPE_DESIGNATION_WORKINGSET){
SpecimenTypeDesignationWorkingsetPopupEditor popup = getNavigationManager().showInPopup(SpecimenTypeDesignationWorkingsetPopupEditor.class);
TypeDesignationWorkingsetEditorIdSet identifierSet;
* @param event
* @throws RegistrationValidationException
*/
- @EventListener
+ @EventBusListenerMethod
public void onDoneWithTypeDesignationEditor(DoneWithPopupEvent event) throws RegistrationValidationException{
if(event.getPopup() instanceof SpecimenTypeDesignationWorkingsetPopupEditor){
if(event.getReason().equals(Reason.SAVE)){
}
- @EventListener(classes=ShowDetailsEvent.class, condition = "#event.type == T(eu.etaxonomy.cdm.vaadin.model.registration.RegistrationWorkingSet)")
- public void onShowRegistrationWorkingSetMessages(ShowDetailsEvent<?,?> event) { // WARNING don't use more specific generic type arguments
+ @EventBusListenerMethod(filter = ShowDetailsEventEntityTypeFilter.RegistrationWorkingSet.class)
+ public void onShowRegistrationWorkingSetMessages(ShowDetailsEvent<?,?> event) {
List<String> messages = new ArrayList<>();
for(RegistrationDTO dto : workingset.getRegistrationDTOs()){
dto.getMessages().forEach(m -> messages.add(dto.getSummary() + ": " + m));
}
}
- @EventListener(classes=ShowDetailsEvent.class, condition = "#event.type == T(eu.etaxonomy.cdm.vaadin.view.registration.RegistrationDTO)")
- public void onShowRegistrationMessages(ShowDetailsEvent<?,?> event) { // WARNING don't use more specific generic type arguments
+
+ @EventBusListenerMethod(filter = ShowDetailsEventEntityTypeFilter.RegistrationDTO.class)
+ public void onShowRegistrationMessages(ShowDetailsEvent<?,?> event) {
RegistrationDTO regDto = regWorkingSetService.loadDtoById((Integer)event.getIdentifier());
if(event.getProperty().equals("messages")){
if(getView() != null){
}
}
- @EventListener
+ @EventBusListenerMethod
public void onEntityChangeEvent(EntityChangeEvent event){
if(workingset == null){
return;
addNewNameRegistrationButton = new Button("new name");
addNewNameRegistrationButton.setDescription("A name which is newly published in this publication.");
addNewNameRegistrationButton.addClickListener(
- e -> eventBus.publishEvent(new TaxonNameEditorAction(EditorActionType.ADD, null, addNewNameRegistrationButton, this))
+ e -> getViewEventBus().publish(this, new TaxonNameEditorAction(EditorActionType.ADD, null, addNewNameRegistrationButton, this))
);
addExistingNameButton = new Button("existing name:");
addExistingNameButton.setDescription("A name which was previously published in a earlier publication.");
addExistingNameButton.setEnabled(false);
addExistingNameButton.addClickListener(
- e -> eventBus.publishEvent(new RegistrationWorkingsetAction(citationID, RegistrationWorkingsetAction.Action.start))
+ e -> getViewEventBus().publish(this, new RegistrationWorkingsetAction(citationID, RegistrationWorkingsetAction.Action.start))
);
existingNameCombobox = new LazyComboBox<TaxonName>(TaxonName.class);
if(dto.getMessages().isEmpty()){
messageButton.setEnabled(false);
} else {
- messageButton.addClickListener(e -> eventBus.publishEvent(
+ messageButton.addClickListener(e -> getViewEventBus().publish(this,
new ShowDetailsEvent<RegistrationDTO, Integer>(
e,
RegistrationDTO.class,
Button editRegistrationButton = new Button(FontAwesome.COG);
editRegistrationButton.setStyleName(ValoTheme.BUTTON_TINY);
editRegistrationButton.setDescription("Edit registration");
- editRegistrationButton.addClickListener(e -> getEventBus().publishEvent(new RegistrationEditorAction(
+ editRegistrationButton.addClickListener(e -> getViewEventBus().publish(this, new RegistrationEditorAction(
EditorActionType.EDIT,
dto.getId(),
null,
if(editButtonGroup.getNameButton() != null){
editButtonGroup.getNameButton().getButton().addClickListener(e -> {
Integer nameId = editButtonGroup.getNameButton().getId();
- getEventBus().publishEvent(new TaxonNameEditorAction(
+ getViewEventBus().publish(this, new TaxonNameEditorAction(
EditorActionType.EDIT,
nameId,
e.getButton(),
TypedEntityReference baseEntityRef = workingsetButton.getBaseEntity();
TypeDesignationWorkingSetType workingsetType = workingsetButton.getType();
Integer registrationEntityID = dto.getId();
- getEventBus().publishEvent(new TypeDesignationWorkingsetEditorAction(
+ getViewEventBus().publish(this, new TypeDesignationWorkingsetEditorAction(
EditorActionType.EDIT,
baseEntityRef,
workingsetType,
*/
protected void addNewTypeDesignationWorkingset(TypeDesignationWorkingSetType newWorkingsetType, Integer registrationEntityId, Window typeDesignationTypeCooser) {
UI.getCurrent().removeWindow(typeDesignationTypeCooser);
- getEventBus().publishEvent(new TypeDesignationWorkingsetEditorAction(
+ getViewEventBus().publish(this, new TypeDesignationWorkingsetEditorAction(
EditorActionType.ADD,
newWorkingsetType,
registrationEntityId,
import java.util.EnumSet;
-import org.springframework.context.event.EventListener;
+import org.vaadin.spring.events.EventScope;
+import org.vaadin.spring.events.annotation.EventBusListenerMethod;
import org.vaadin.viritin.fields.LazyComboBox;
import com.vaadin.server.SystemError;
import eu.etaxonomy.cdm.model.reference.ReferenceType;
import eu.etaxonomy.cdm.persistence.hibernate.permission.CRUD;
import eu.etaxonomy.cdm.service.CdmFilterablePagingProvider;
+import eu.etaxonomy.cdm.vaadin.event.EditorActionTypeFilter;
import eu.etaxonomy.cdm.vaadin.event.ReferenceEditorAction;
import eu.etaxonomy.cdm.vaadin.event.RegistrationEditorAction;
import eu.etaxonomy.cdm.vaadin.ui.RegistrationUIDefaults;
super();
}
+
/**
* {@inheritDoc}
*/
super.handleViewExit();
}
- @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).ADD")
+
+ @EventBusListenerMethod(filter = EditorActionTypeFilter.Add.class)
public void onReferenceEditorActionAdd(ReferenceEditorAction event) {
if(getView() == null || getView().getNewPublicationButton() != event.getSourceComponent()){
return;
}
+
newReferencePopup = getNavigationManager().showInPopup(ReferencePopupEditor.class);
EnumSet<ReferenceType> refTypes = RegistrationUIDefaults.PRINTPUB_REFERENCE_TYPES.clone();
refTypes.remove(ReferenceType.Section);
newReferencePopup.loadInEditor(null);
}
- @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).REMOVE")
+ @EventBusListenerMethod(filter = EditorActionTypeFilter.Remove.class)
public void onReferenceEditorActionRemove(ReferenceEditorAction event) {
if(getView().getRemoveNewPublicationButton() != event.getSourceComponent()){
getView().getNewPublicationLabel().setVisible(false);
}
- @EventListener
+ @EventBusListenerMethod
public void onDoneWithPopupEvent(DoneWithPopupEvent event){
+
if(event.getPopup() == newReferencePopup){
if(event.getReason() == Reason.SAVE){
}
}
- @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).ADD")
+ @EventBusListenerMethod(filter = EditorActionTypeFilter.Add.class)
public void onRegistrationEditorActionAdd(RegistrationEditorAction event) {
if(getView().getContinueButton() != event.getSourceComponent()){
return;
}
+
Integer referenceId = null;
LazyComboBox<Reference> referenceCombobox = getView().getReferenceCombobox();
referenceCombobox.commit();
getView().getContinueButton().setEnabled(false);
}
registrationInProgress = true;
- eventBus.publishEvent(new NavigationEvent(RegistrationWorksetViewBean.NAME, Integer.toString(referenceId)));
+ viewEventBus.publish(EventScope.UI, this, new NavigationEvent(RegistrationWorksetViewBean.NAME, Integer.toString(referenceId)));
}
});
newPublicationButton = new Button("New");
- newPublicationButton.addClickListener( e -> eventBus.publishEvent(
+ newPublicationButton.addClickListener( e -> getViewEventBus().publish(this,
new ReferenceEditorAction(EditorActionType.ADD, newPublicationButton)
));
newPublicationButton.setCaption("New");
removeNewPublicationButton = new Button("Delete");
removeNewPublicationButton.setStyleName(ValoTheme.BUTTON_DANGER);
removeNewPublicationButton.setWidth(ELEMENT_WIDTH);
- removeNewPublicationButton.addClickListener( e -> eventBus.publishEvent(
+ removeNewPublicationButton.addClickListener( e -> getViewEventBus().publish(this,
new ReferenceEditorAction(EditorActionType.REMOVE, removeNewPublicationButton)
));
if(referenceCombobox.getValue() != null){
refId = referenceCombobox.getValue().getId();
}
- eventBus.publishEvent(
+ getViewEventBus().publish(this,
new RegistrationEditorAction(EditorActionType.ADD,
// passing the refId is hack, bit for some reason the presenter is always referring to the wrong view
refId,
import org.apache.log4j.Logger;
import org.hibernate.HibernateException;
-import org.springframework.context.event.EventListener;
+import org.vaadin.spring.events.annotation.EventBusListenerMethod;
import eu.etaxonomy.cdm.api.service.IService;
import eu.etaxonomy.cdm.cache.CdmTransientEntityCacher;
* @return
*/
protected abstract IService<DTO> getService();
-
+
@SuppressWarnings("unchecked")
@Override
- @EventListener // the generic type parameter <DTO> must not be used here otherwise events will not be received
+ @EventBusListenerMethod
public void onEditorPreSaveEvent(EditorPreSaveEvent preSaveEvent){
if(!isFromOwnView(preSaveEvent)){
@SuppressWarnings("unchecked")
@Override
- @EventListener // the generic type parameter <DTO> must not be used here otherwise events will not be received
- public void onEditorSaveEvent(EditorSaveEvent saveEvent){
+ @EventBusListenerMethod
+ public void onEditorSaveEvent(EditorSaveEvent<DTO> saveEvent){
if(!isFromOwnView(saveEvent)){
return;
}
-
-
+
// the bean is now updated with the changes made by the user
- DTO bean = (DTO) saveEvent.getBean();
+ DTO bean = saveEvent.getBean();
if(logger.isTraceEnabled()){
PersistentContextAnalyzer pca = new PersistentContextAnalyzer(bean);
EntityChangeEvent changeEvent = getStore().saveBean(bean);
if(changeEvent != null){
- eventBus.publishEvent(changeEvent);
+ viewEventBus.publish(this, changeEvent);
}
} catch (HibernateException e){
if(newAuthorityCreated != null){
}
/**
- * EditorPresneters for beans with transient properties should overwrite this method to
+ * EditorPresenters for beans with transient properties should overwrite this method to
* update the beanItem with the changes made to the transient properties.
* <p>
* This is necessary because Vaadin MethodProperties are readonly when no setter is
protected final void deleteBean(DTO bean){
EntityChangeEvent changeEvent = getStore().deleteBean(bean);
if(changeEvent != null){
- eventBus.publishEvent(changeEvent);
+ viewEventBus.publish(this, changeEvent);
}
}
package eu.etaxonomy.vaadin.mvp;
import org.hibernate.FlushMode;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.ApplicationEventPublisher;
-import org.springframework.context.event.EventListener;
+import org.vaadin.spring.events.annotation.EventBusListenerMethod;
import eu.etaxonomy.cdm.vaadin.event.AbstractEditorAction;
import eu.etaxonomy.vaadin.mvp.event.EditorDeleteEvent;
FlushMode previousPreSaveEvenFlushMode = null;
- @Autowired
- protected ApplicationEventPublisher eventBus;
-
protected BeanInstantiator<DTO> beanInstantiator = null;
/**
this.beanInstantiator = beanInstantiator;
}
- /**
- * Regarding changing the Flush mode see see also {@link ViewScopeConversationHolder}
- *
- * @param preSaveEvent
- */
- @EventListener
+ @EventBusListenerMethod
public void onEditorPreSaveEvent(EditorPreSaveEvent<DTO> preSaveEvent){
- if(!isFromOwnView(preSaveEvent)){
- return;
- }
-// getSession().setFlushMode(FlushMode.AUTO);
-
}
- @EventListener
+ @EventBusListenerMethod
public void onEditorSaveEvent(EditorSaveEvent<DTO> saveEvent){
- if(!isFromOwnView(saveEvent)){
- return;
- }
+
DTO bean = saveEvent.getBean();
- try {
- saveBean(bean);
- } catch(Exception e){
-// if(getSession().isOpen()){
-// getSession().clear();
-// }
- throw e; // re-throw after cleaning up the session
- } finally {
-// if(getSession().isOpen()){
-// getSession().setFlushMode(previousPreSaveEvenFlushMode);
-// }
-// previousPreSaveEvenFlushMode = null;
- }
+ saveBean(bean);
}
- /**
+ /**
* Regarding changing the Flush mode see see also {@link ViewScopeConversationHolder}
*
* @param saveEvent
*/
- @EventListener
+ @EventBusListenerMethod
public void onEditorDeleteEvent(EditorDeleteEvent<DTO> deleteEvent){
- if(!isFromOwnView(deleteEvent)){
- return;
- }
+
FlushMode previousFlushMode = getSession().getFlushMode();
getSession().setFlushMode(FlushMode.AUTO);
deleteBean(deleteEvent.getBean());
import java.util.Map;
import org.apache.log4j.Logger;
+import org.vaadin.spring.events.EventScope;
import com.vaadin.data.Validator.InvalidValueException;
import com.vaadin.data.fieldgroup.BeanFieldGroup;
public void preCommit(CommitEvent commitEvent) throws CommitException {
logger.debug("preCommit(), publishing EditorPreSaveEvent");
// notify the presenter to start a transaction
- eventBus.publishEvent(new EditorPreSaveEvent<DTO>(AbstractPopupEditor.this, getBean()));
+ viewEventBus.publish(this, new EditorPreSaveEvent<DTO>(AbstractPopupEditor.this, getBean()));
}
@Override
logger.trace("postCommit() publishing EditorSaveEvent for " + getBean().toString());
}
// notify the presenter to persist the bean and to commit the transaction
- eventBus.publishEvent(new EditorSaveEvent<DTO>(AbstractPopupEditor.this, getBean()));
+ viewEventBus.publish(this, new EditorSaveEvent<DTO>(AbstractPopupEditor.this, getBean()));
if(logger.isTraceEnabled()){
logger.trace("postCommit() publishing DoneWithPopupEvent");
}
// notify the NavigationManagerBean to close the window and to dispose the view
- eventBus.publishEvent(new DoneWithPopupEvent(AbstractPopupEditor.this, Reason.SAVE));
+ viewEventBus.publish(EventScope.UI, this, new DoneWithPopupEvent(AbstractPopupEditor.this, Reason.SAVE));
} catch (Exception e) {
logger.error(e);
throw new CommitException("Failed to store data to backend", e);
@Override
public void cancel() {
fieldGroup.discard();
- eventBus.publishEvent(new DoneWithPopupEvent(this, Reason.CANCEL));
+ viewEventBus.publish(EventScope.UI, this, new DoneWithPopupEvent(this, Reason.CANCEL));
}
/**
* @return
*/
private void delete() {
- eventBus.publishEvent(new EditorDeleteEvent<DTO>(this, fieldGroup.getItemDataSource().getBean()));
- eventBus.publishEvent(new DoneWithPopupEvent(this, Reason.DELETE));
+ viewEventBus.publish(this, new EditorDeleteEvent<DTO>(this, fieldGroup.getItemDataSource().getBean()));
+ viewEventBus.publish(EventScope.UI, this, new DoneWithPopupEvent(this, Reason.DELETE));
}
/**
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
+import org.vaadin.spring.events.EventBus;
import eu.etaxonomy.cdm.api.application.CdmRepository;
import eu.etaxonomy.cdm.vaadin.event.AbstractEditorAction;
private V view;
-
protected V getView() {
if(view == null){
Logger.getLogger(this.getClass()).warn("CDM-VAADIN#6562: presenter " + toString() + " without view.");
@Autowired
private NavigationManager navigationManager;
+ protected EventBus.ViewEventBus viewEventBus;
+
+ @Autowired
+ protected void setViewEventBus(EventBus.ViewEventBus viewEventBus){
+ this.viewEventBus = viewEventBus;
+ eventViewBusSubscription(viewEventBus);
+ }
+
+ /**
+ * Override if needed, e.g. to skip subscription
+ *
+ * @param viewEventBus
+ */
+ protected void eventViewBusSubscription(EventBus.ViewEventBus viewEventBus){
+ viewEventBus.subscribe(this);
+ }
+
+ public void unsubscribeFromEventBuses(){
+ viewEventBus.unsubscribe(this);
+ }
+
// protected DefaultTransactionDefinition definition = null;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
-import org.springframework.context.ApplicationEventPublisher;
+import org.vaadin.spring.events.EventBus;
import com.vaadin.ui.CustomComponent;
private ApplicationContext applicationContext;
@Autowired
- protected ApplicationEventPublisher eventBus;
+ EventBus.ViewEventBus viewEventBus;
@SuppressWarnings("unchecked")
@PostConstruct
this.applicationContext = applicationContext;
}
- public ApplicationEventPublisher getEventBus(){
- return eventBus;
+ public EventBus.ViewEventBus getViewEventBus(){
+ return viewEventBus;
}
@Override
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
-import org.springframework.context.ApplicationEventPublisher;
-import org.springframework.context.event.EventListener;
+import org.vaadin.spring.events.EventBus.UIEventBus;
+import org.vaadin.spring.events.annotation.EventBusListenerMethod;
import com.vaadin.navigator.View;
import com.vaadin.spring.annotation.SpringView;
@Autowired
private ApplicationContext beanManager;
+ private UIEventBus uiEventBus;
+
@Autowired
- private ApplicationEventPublisher eventBus;
+ private void setUiEventBus(UIEventBus uiEventBus){
+ this.uiEventBus = uiEventBus;
+ uiEventBus.subscribe(this);
+ }
private MainMenu mainMenuLookup = null;
this.mainMenuLookup = mainMenu;
}
- @EventListener
+ @EventBusListenerMethod
protected void doMenuItemLookup(UIInitializedEvent event) {
if (mainMenuLookup == null) {
import java.util.stream.StreamSupport;
import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.ApplicationEventPublisher;
-import org.springframework.context.event.EventListener;
+import org.vaadin.spring.events.EventBus;
+import org.vaadin.spring.events.annotation.EventBusListenerMethod;
import com.vaadin.server.FontAwesome;
import com.vaadin.server.Resource;
private Button menuToggle;
@Autowired
- ApplicationEventPublisher eventBus;
+ protected EventBus.UIEventBus uiEventBus;
+
+ protected void setUIEventBus(EventBus.UIEventBus uiEventBus){
+ this.uiEventBus = uiEventBus;
+ uiEventBus.subscribe(this);
+ }
public ValoMainMenuBean() {
setPrimaryStyleName(ValoTheme.MENU_ROOT);
}
private void onMenuItemClicked(String navigationResource) {
- eventBus.publishEvent(new NavigationEvent(navigationResource));
+ uiEventBus.publish(this, new NavigationEvent(navigationResource));
}
- @EventListener
+ @EventBusListenerMethod
protected void onNavigationEvent(NavigationEvent e) {
List<MainMenuItemBean> menuItems = StreamSupport.stream(menuArea.spliterator(), false)
.filter(component -> MainMenuItemBean.class.isAssignableFrom(component.getClass()))
}
}
- @EventListener
- protected void afterViewChange(AfterViewChangeEvent event) {
+ @EventBusListenerMethod
+ protected void afterViewChange(org.vaadin.spring.events.Event<AfterViewChangeEvent> event) {
removeStyleName(MENU_VISIBLE);
}
package eu.etaxonomy.vaadin.ui.navigation;
import java.util.Arrays;
+import java.util.Collection;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Lazy;
-import org.springframework.context.event.EventListener;
import org.springframework.context.event.PojoEventListenerManager;
+import org.vaadin.spring.events.EventBus;
+import org.vaadin.spring.events.annotation.EventBusListenerMethod;
import com.vaadin.navigator.ViewChangeListener;
import com.vaadin.navigator.ViewDisplay;
import eu.etaxonomy.vaadin.ui.UIInitializedEvent;
import eu.etaxonomy.vaadin.ui.view.DoneWithPopupEvent;
import eu.etaxonomy.vaadin.ui.view.PopEditorOpenedEvent;
-import eu.etaxonomy.vaadin.ui.view.PopupEditorFactory;
import eu.etaxonomy.vaadin.ui.view.PopupView;
@UIScope
private List<ViewChangeListener> viewChangeListeners;
@Autowired
- private PojoEventListenerManager eventListenerManager;
+ protected ApplicationContext applicationContext;
@Autowired
- private PopupEditorFactory popupEditorFactory;
+ private PojoEventListenerManager eventListenerManager;
+
+ protected EventBus.UIEventBus uiEventBus;
+
+ @Autowired
+ protected void setViewEventBus(EventBus.UIEventBus uiEventBus){
+ this.uiEventBus = uiEventBus;
+ uiEventBus.subscribe(this);
+ }
+
/**
* This reference will cause the scoped UserHelper being initialized
// this.uriFragmentManager = uriFragmentManager;
// }
- @Autowired
- ApplicationEventPublisher eventBus;
-
public NavigationManagerBean() {
popupMap = new HashMap<>();
}
+ private Collection<PopupView> popupViews = new HashSet<>();
- private <P extends PopupView> PopupView findPopupView(Class<P> popupViewClass){
- return popupEditorFactory.newPopupView(popupViewClass);
- }
+// @Lazy
+// @Autowired(required=false)
+// private void popUpViews(Collection<PopupView> popupViews){
+// this.popupViews = popupViews;
+// // popupViews.forEach(view -> this.popupViews.put(view.getClass(), view));
+// }
+
+ private <P extends PopupView> P findPopupView(Class<P> type){
+ P viewBean = applicationContext.getBean(type);
+ if(viewBean == null){
+ throw new NullPointerException("no popup-view bean of type " + type.getName() + " found");
+ }
+ return viewBean;
+ // return popupViews.stream().filter(p -> p.getClass().equals(type)).findFirst();
+ }
- @EventListener
+ @EventBusListenerMethod
protected void onUIInitialized(UIInitializedEvent e) {
init(UI.getCurrent(), uriFragmentManager, viewDisplay);
+ addProvider(viewProvider);
viewChangeListeners.forEach(vcl -> addViewChangeListener(vcl));
}
//eventBus.publishEvent(new NavigationEvent(navigationState));
}
- @EventListener
+ @EventBusListenerMethod
protected void onNavigationEvent(NavigationEvent e) {
navigateTo(e.getViewName(), false);
}
@Override
public <T extends PopupView> T showInPopup(Class<T> popupType) {
- PopupView popupView = findPopupView(popupType); // TODO make better use of Optional
+ PopupView popupView = findPopupView(popupType);
if(AbstractPopupEditor.class.isAssignableFrom(popupView.getClass())){
AbstractEditorPresenter presenter = ((AbstractPopupEditor)popupView).presenter();
// see #6843
window.setHeight("100%");
window.setContent(popupView.asComponent());
- // window.addCloseListener(e -> popupView.cancel());
+ window.addCloseListener(e -> popupView.cancel());
UI.getCurrent().addWindow(window);
popupView.viewEntered();
popupView.focusFirst();
- eventBus.publishEvent(new PopEditorOpenedEvent(this, popupView));
+ uiEventBus.publish(this, new PopEditorOpenedEvent(this, popupView));
popupMap.put(popupView, window);
return (T) popupView;
}
- @EventListener
+ @EventBusListenerMethod
protected void onDoneWithTheEditor(DoneWithPopupEvent e) {
PopupView popup = e.getPopup();
popupMap.remove(popup);
}
if(AbstractPopupEditor.class.isAssignableFrom(popup.getClass())){
- AbstractEditorPresenter presenter = ((AbstractPopupEditor)popup).presenter();
- eventListenerManager.removeEventListeners(presenter);
+ ((AbstractPopupEditor)popup).presenter().unsubscribeFromEventBuses();
}
}
package eu.etaxonomy.vaadin.ui.navigation;
import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.ApplicationEventPublisher;
+import org.vaadin.spring.events.EventBus.UIEventBus;
import com.vaadin.navigator.Navigator.UriFragmentManager;
import com.vaadin.server.Page;
private static final long serialVersionUID = -2033745435437337863L;
@Autowired
- ApplicationEventPublisher eventBus;
+ UIEventBus uiEventBus;
public NavigationUriFragmentManager() {
super(Page.getCurrent());
@Override
public void uriFragmentChanged(UriFragmentChangedEvent event) {
- eventBus.publishEvent(new NavigationEvent(getState()));
+ uiEventBus.publish(this, new NavigationEvent(getState()));
}
}
import java.util.Collection;
import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.annotation.Lazy;
+import org.vaadin.spring.events.EventBus.UIEventBus;
import com.vaadin.navigator.View;
import com.vaadin.navigator.ViewChangeListener;
private NavigationManager navigationManager;
@Autowired
- ApplicationEventPublisher eventBus;
+ UIEventBus uiEventBus;
@Override
public boolean beforeViewChange(ViewChangeEvent event) {
@Override
public void afterViewChange(ViewChangeEvent event) {
- eventBus.publishEvent(new AfterViewChangeEvent());
+ uiEventBus.publish(this, new AfterViewChangeEvent());
}
}
package eu.etaxonomy.vaadin.ui.view;
+/**
+ * Event indicating the end of a popup view which is send via the uiEventBus to the NavigationManagerBean.
+ * +
+ * @author a.kohlbecker
+ * @since Feb 1, 2018
+ *
+ */
public class DoneWithPopupEvent {
+
public enum Reason {
CANCEL, SAVE, DELETE;
}
this.reason = reason;
}
+
public Reason getReason() {
return reason;
}
+++ /dev/null
-/**
-* Copyright (C) 2017 EDIT
-* European Distributed Institute of Taxonomy
-* http://www.e-taxonomy.eu
-*
-* The contents of this file are subject to the Mozilla Public License Version 1.1
-* See LICENSE.TXT at the top of this package for the full license terms.
-*/
-package eu.etaxonomy.vaadin.ui.view;
-
-import java.io.Serializable;
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-
-import javax.sql.DataSource;
-
-import org.hibernate.SessionFactory;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.context.ApplicationEventPublisher;
-import org.springframework.context.annotation.Lazy;
-import org.springframework.transaction.PlatformTransactionManager;
-
-import com.vaadin.spring.annotation.SpringComponent;
-import com.vaadin.spring.annotation.UIScope;
-
-import eu.etaxonomy.cdm.api.application.CdmRepository;
-import eu.etaxonomy.cdm.service.IRegistrationWorkingSetService;
-import eu.etaxonomy.cdm.service.ISpecimenTypeDesignationWorkingSetService;
-import eu.etaxonomy.cdm.vaadin.view.name.NameTypeDesignationPresenter;
-import eu.etaxonomy.cdm.vaadin.view.name.SpecimenTypeDesignationWorkingsetEditorPresenter;
-import eu.etaxonomy.vaadin.mvp.AbstractEditorPresenter;
-import eu.etaxonomy.vaadin.mvp.AbstractPopupEditor;
-import eu.etaxonomy.vaadin.mvp.AbstractPresenter;
-import eu.etaxonomy.vaadin.mvp.AbstractView;
-import eu.etaxonomy.vaadin.ui.navigation.NavigationManager;
-
-/**
- * @author a.kohlbecker
- * @since May 30, 2017
- *
- */
-@SpringComponent
-@UIScope
-public class PopupEditorFactory implements Serializable {
-
-
- private static final long serialVersionUID = -3371003970671610677L;
-
- @Autowired
- protected ApplicationEventPublisher eventBus;
-
- @Autowired
- @Qualifier("cdmRepository")
- private CdmRepository repo;
-
- @Autowired
- private SessionFactory sessionFactory;
-
- @Autowired
- private DataSource dataSource;
-
- @Autowired
- private PlatformTransactionManager transactionManager;
-
- @Autowired
- private ISpecimenTypeDesignationWorkingSetService specimenTypeDesignationWorkingSetService;
-
- @Autowired
- private IRegistrationWorkingSetService registrationWorkingSetService;
-
- @Autowired
- @Lazy
- private NavigationManager navigationManager;
-
- private Field presenterRepoField;
- private Field presenterNavigationManagerField;
- private Field presenterEventBusField;
-
- private Field viewEventBusField;
- private Field specimenTypeDesignationWorkingSetServiceField;
- private Method viewInjectPresenterMethod;
-
- private Field Field;
-
- private Method viewInitMethod;
-
- public PopupEditorFactory(){
- initFieldsAccess();
- }
-
-
- /**
- *
- */
- private void initFieldsAccess() {
-
- try {
- presenterRepoField = AbstractPresenter.class.getDeclaredField("repo");
- presenterRepoField.setAccessible(true);
-
- presenterNavigationManagerField = AbstractPresenter.class.getDeclaredField("navigationManager");
- presenterNavigationManagerField.setAccessible(true);
-
- presenterEventBusField = AbstractEditorPresenter.class.getDeclaredField("eventBus");
- presenterEventBusField.setAccessible(true);
-
- viewEventBusField = AbstractView.class.getDeclaredField("eventBus");
- viewEventBusField.setAccessible(true);
-
- viewInjectPresenterMethod = AbstractView.class.getDeclaredMethod("injectPresenter", AbstractPresenter.class);
- viewInjectPresenterMethod.setAccessible(true);
-
- viewInitMethod = AbstractView.class.getDeclaredMethod("init");
- viewInitMethod.setAccessible(true);
-
- specimenTypeDesignationWorkingSetServiceField = SpecimenTypeDesignationWorkingsetEditorPresenter.class.getDeclaredField("specimenTypeDesignationWorkingSetService");
- specimenTypeDesignationWorkingSetServiceField.setAccessible(true);
-
- Field = NameTypeDesignationPresenter.class.getDeclaredField("registrationWorkingSetService");
- Field.setAccessible(true);
-
- } catch (NoSuchFieldException | SecurityException | NoSuchMethodException e) {
- throw new RuntimeException("Severe error during initialization. Please check the classes AbstractPresenter, AbstractEditorPresenter, AbstractView for modificactions.", e);
- }
-
- }
-
-
- /**
- * @param popupViewClass
- * @return
- */
- public <V extends PopupView, P extends AbstractPresenter> PopupView newPopupView(Class<V> popupViewClass) {
-
- Class<? extends AbstractPresenter<?>> presenterClass = findGenericPresenterType(popupViewClass);
- try {
-
- P presenter = (P) presenterClass.newInstance();
-
- injectPresenterBeans(presenterClass, presenter);
-
- PopupView view = popupViewClass.newInstance();
- if(AbstractView.class.isAssignableFrom(popupViewClass)){
- AbstractView<P> abstractView = (AbstractView<P>)view;
- viewEventBusField.set(abstractView, eventBus);
- viewInjectPresenterMethod.invoke(abstractView, presenter);
- // invoke the @PostConstruct method
-
- viewInitMethod.invoke(abstractView);
- }
- return view;
- } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
- throw new RuntimeException(String.format("Error creating the view class '%s' with presenter class '%s'", popupViewClass, presenterClass), e);
- }
- }
-
-
- /**
- * @param presenterClass
- * @param presenter
- * @throws IllegalAccessException
- * @throws InvocationTargetException
- * @throws IllegalArgumentException
- */
- public <P extends AbstractPresenter> void injectPresenterBeans(
- Class<? extends AbstractPresenter<?>> presenterClass, P presenter) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
- presenterRepoField.set(presenter, repo);
- presenterNavigationManagerField.set(presenter, navigationManager);
-
- if(AbstractEditorPresenter.class.isAssignableFrom(presenterClass)){
- presenterEventBusField.set(presenter, eventBus);
- }
- if(SpecimenTypeDesignationWorkingsetEditorPresenter.class.equals(presenterClass)){
- specimenTypeDesignationWorkingSetServiceField.set(presenter, specimenTypeDesignationWorkingSetService);
- }
- if(NameTypeDesignationPresenter.class.equals(presenterClass)){
- Field.set(presenter, registrationWorkingSetService);
- }
- }
-
- /**
- * @param popupViewClass
- * @return
- */
- @SuppressWarnings("unchecked")
- private Class<? extends AbstractPresenter<?>> findGenericPresenterType(Class<? extends PopupView> popupViewClass) {
-
- ParameterizedType genericSuperClass = (ParameterizedType)popupViewClass.getGenericSuperclass();
- Type[] typeArgs = genericSuperClass.getActualTypeArguments();
- if(AbstractPopupEditor.class.isAssignableFrom(popupViewClass)){
- return (Class<? extends AbstractPresenter<?>>) typeArgs[1];
- } else {
- return (Class<? extends AbstractPresenter<?>>) typeArgs[0];
- }
- }
-
-
-}
import java.lang.reflect.InvocationTargetException;
import org.apache.log4j.Logger;
-import org.springframework.context.ApplicationEventPublisher;
import org.unitils.dbunit.annotation.DataSet;
import org.unitils.spring.annotation.SpringBean;
import org.unitils.spring.annotation.SpringBeanByType;
+import org.vaadin.spring.events.EventBus.ViewEventBus;
import com.vaadin.ui.ListSelect;
import eu.etaxonomy.cdm.vaadin.view.reference.ReferenceEditorPresenter;
import eu.etaxonomy.cdm.vaadin.view.reference.ReferencePopupEditorView;
import eu.etaxonomy.vaadin.component.ToOneRelatedEntityCombobox;
-import eu.etaxonomy.vaadin.ui.view.PopupEditorFactory;
/**
* @author a.kohlbecker
private static final Logger logger = Logger.getLogger(CdmEditorPresenterTest.class);
@SpringBeanByType
- protected ApplicationEventPublisher eventBus;
+ protected ViewEventBus viewEventBus;
+
+ @SpringBeanByType
+ private ReferenceEditorPresenter referencePresenter;
@SpringBean("cdmRepository")
private CdmRepository repo;
- @SpringBeanByType
- protected PopupEditorFactory factory;
-
@DataSet
// @Test test setup not jet working :(
public void testSaveReference() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
- ReferenceEditorPresenter referencePresenter = new ReferenceEditorPresenter();
- factory.injectPresenterBeans(ReferenceEditorPresenter.class, referencePresenter);
TestReferenceEditorView testView = new TestReferenceEditorView();
referencePresenter.init(testView);
BGBM BDI Projects / cdm-vaadin.git / commitdiff