/** * Use instead of {@link #hide()}, {@link #disable(org.apache.isis.applib.services.i18n.TranslatableString)} and {@link #invalidate(org.apache.isis.applib.services.i18n.TranslatableString)}; just delegates to * appropriate vetoing method based upon the {@link #getEventPhase() phase}. * * <p> * If hiding, just pass <tt>null</tt> for the parameter. * </p> * * @param translatableReason - reason why the interaction is being invalidated (ignored if in {@link org.apache.isis.applib.services.eventbus.AbstractDomainEvent.Phase#HIDE hide} phase). * * @see #veto(String, Object...) */ @Programmatic public void veto(final TranslatableString translatableReason) { switch (getEventPhase()) { case HIDE: hide(); break; case DISABLE: disable(translatableReason); break; case VALIDATE: invalidate(translatableReason); break; } } //endregion
private void veto( final Throwable exception, final AbstractDomainEvent<?> domainEvent, final AbstractDomainEvent.Phase phase) { final String exceptionMessage = exception.getMessage(); LOG.warn("Exception thrown during {} phase, to be safe will veto the domain event, msg='{}', class='{}'", phase, exceptionMessage, exception.getClass().getName()); final String message = exceptionMessage != null ? exceptionMessage : exception.getClass().getName() + " thrown."; domainEvent.veto(message); }
/** * The subject of the event, which will be either the {@link #getSource() source} for a regular action, or the * {@link #getMixedIn() mixed-in} domain object for a mixin. */ public Object getSubject() { final Object mixedIn = getMixedIn(); return mixedIn != null ? mixedIn : getSource(); }
@Test public void hidden_phase_and_veto_using_null() throws Exception { // given ev.setEventPhase(AbstractDomainEvent.Phase.HIDE); // when ev.veto((String)null); // then ... vetoes Assert.assertTrue(ev.isHidden()); Assert.assertFalse(ev.isDisabled()); Assert.assertNull(ev.getDisabledReason()); Assert.assertFalse(ev.isInvalid()); Assert.assertNull(ev.getInvalidityReason()); }
@Test public void disable_phase_and_veto_using_translatable() throws Exception { // given ev.setEventPhase(AbstractDomainEvent.Phase.DISABLE); // when final TranslatableString reason = TranslatableString.tr("no, you can't do that"); ev.veto(reason); // then Assert.assertFalse(ev.isHidden()); Assert.assertTrue(ev.isDisabled()); Assert.assertEquals(reason, ev.getDisabledReasonTranslatable()); Assert.assertFalse(ev.isInvalid()); Assert.assertNull(ev.getInvalidityReason()); }
@Test public void validate_phase_and_veto_using_translatable() throws Exception { // given ev.setEventPhase(AbstractDomainEvent.Phase.VALIDATE); // when final TranslatableString reason = TranslatableString.tr("no, you can't do that"); ev.veto(reason); // then Assert.assertFalse(ev.isHidden()); Assert.assertFalse(ev.isDisabled()); Assert.assertNull(ev.getDisabledReason()); Assert.assertTrue(ev.isInvalid()); Assert.assertEquals(reason, ev.getInvalidityReasonTranslatable()); }
@Test public void validate_phase_and_attempt_to_veto_with_null() throws Exception { // given ev.setEventPhase(AbstractDomainEvent.Phase.VALIDATE); // expect expectedException.expect(IllegalArgumentException.class); // when ev.veto((String)null); }
protected void processException( final Throwable exception, final Object event) { final AbstractDomainEvent<?> domainEvent = asDomainEvent(event); if (domainEvent == null) { if (LOG.isDebugEnabled()) { LOG.debug("Ignoring exception '%s' (%s), not a subclass of AbstractDomainEvent", exception.getMessage(), exception.getClass().getName()); } return; } if(LOG.isDebugEnabled()) { LOG.debug("Exception stack trace (to help diagnose issue): ", exception); } final AbstractDomainEvent.Phase phase = domainEvent.getEventPhase(); switch (phase) { case HIDE: case DISABLE: case VALIDATE: veto(exception, domainEvent, phase); break; case EXECUTING: case EXECUTED: abort(exception, phase); throw new RuntimeException(exception); } }
@Test public void hidden_phase_and_veto_using_non_null_string() throws Exception { // given ev.setEventPhase(AbstractDomainEvent.Phase.HIDE); // when ev.veto("hidden"); // then ... vetoes Assert.assertTrue(ev.isHidden()); Assert.assertFalse(ev.isDisabled()); Assert.assertNull(ev.getDisabledReason()); Assert.assertFalse(ev.isInvalid()); Assert.assertNull(ev.getInvalidityReason()); }
@Test public void disable_phase_and_attempt_to_veto_with_null() throws Exception { // given final AbstractDomainEvent ev = new AbstractDomainEvent() { }; ev.setEventPhase(AbstractDomainEvent.Phase.DISABLE); // expect expectedException.expect(IllegalArgumentException.class); // when ev.veto((String)null); }
@Test public void validate_phase_and_veto_using_non_null_string() throws Exception { // given ev.setEventPhase(AbstractDomainEvent.Phase.VALIDATE); // when final String reason = "no, you can't do that"; ev.veto(reason); // then Assert.assertFalse(ev.isHidden()); Assert.assertFalse(ev.isDisabled()); Assert.assertNull(ev.getDisabledReason()); Assert.assertTrue(ev.isInvalid()); Assert.assertEquals(reason, ev.getInvalidityReason()); }
switch (getEventPhase()) { case HIDE: hide(); break; case DISABLE: throw new IllegalArgumentException("Reason must be non-null"); disable(String.format(reason, args)); break; case VALIDATE: throw new IllegalArgumentException("Reason must be non-null"); invalidate(String.format(reason, args)); break;
@Test public void disable_phase_and_veto_using_non_null_string() throws Exception { // given ev.setEventPhase(AbstractDomainEvent.Phase.DISABLE); // when final String reason = "no, you can't do that"; ev.veto(reason); // then Assert.assertFalse(ev.isHidden()); Assert.assertTrue(ev.isDisabled()); Assert.assertEquals(reason, ev.getDisabledReason()); Assert.assertFalse(ev.isInvalid()); Assert.assertNull(ev.getInvalidityReason()); }
@Test public void hidden_phase_and_veto_using_translatable() throws Exception { // given ev.setEventPhase(AbstractDomainEvent.Phase.HIDE); // when final TranslatableString reason = TranslatableString.tr("hidden"); ev.veto(reason); // then ... vetoes Assert.assertTrue(ev.isHidden()); Assert.assertFalse(ev.isDisabled()); Assert.assertNull(ev.getDisabledReason()); Assert.assertFalse(ev.isInvalid()); Assert.assertNull(ev.getInvalidityReason()); }