Examples with EventListener won.bot.framework.eventbot.listener.EventListener used on opensource projects

Example 26 with EventListener

use of won.bot.framework.eventbot.listener.EventListener in project webofneeds by researchstudio-sat.

the class TelegramMessageReceivedAction method doRun.

@Override
protected void doRun(Event event, EventListener executingListener) throws Exception {
    EventBus bus = getEventListenerContext().getEventBus();
    EventListenerContext ctx = getEventListenerContext();
    if (event instanceof TelegramMessageReceivedEvent && ctx.getBotContextWrapper() instanceof TelegramBotContextWrapper) {
        TelegramBotContextWrapper botContextWrapper = (TelegramBotContextWrapper) ctx.getBotContextWrapper();
        Update update = ((TelegramMessageReceivedEvent) event).getUpdate();
        Message message = update.getMessage();
        CallbackQuery callbackQuery = update.getCallbackQuery();
        if (message != null && message.isCommand()) {
            wonTelegramBotHandler.getCommandRegistry().executeCommand(wonTelegramBotHandler, message);
        } else if (callbackQuery != null && update.hasCallbackQuery()) {
            message = callbackQuery.getMessage();
            String data = callbackQuery.getData();
            WonURI correspondingURI = botContextWrapper.getWonURIForMessageId(message.getMessageId());
            AnswerCallbackQuery answerCallbackQuery = new AnswerCallbackQuery();
            answerCallbackQuery.setCallbackQueryId(callbackQuery.getId());
            switch(correspondingURI.getType()) {
                case NEED:
                    break;
                case CONNECTION:
                    if ("0".equals(data)) {
                        // CLOSE CONNECTION
                        Dataset connectionRDF = getEventListenerContext().getLinkedDataSource().getDataForResource(correspondingURI.getUri());
                        Connection con = RdfUtils.findFirst(connectionRDF, x -> new ConnectionModelMapper().fromModel(x));
                        bus.publish(new CloseCommandEvent(con));
                        answerCallbackQuery.setText("Closed Connection");
                    } else if ("1".equals(data)) {
                        // ACCEPT CONNECTION
                        Dataset connectionRDF = getEventListenerContext().getLinkedDataSource().getDataForResource(correspondingURI.getUri());
                        URI remoteNeed = WonRdfUtils.ConnectionUtils.getRemoteNeedURIFromConnection(connectionRDF, correspondingURI.getUri());
                        URI localNeed = WonRdfUtils.ConnectionUtils.getLocalNeedURIFromConnection(connectionRDF, correspondingURI.getUri());
                        bus.publish(new ConnectCommandEvent(localNeed, remoteNeed));
                        answerCallbackQuery.setText("Opened Connection");
                    }
                    break;
            }
            wonTelegramBotHandler.answerCallbackQuery(answerCallbackQuery);
            EditMessageReplyMarkup editMessageReplyMarkup = new EditMessageReplyMarkup();
            editMessageReplyMarkup.setMessageId(message.getMessageId());
            editMessageReplyMarkup.setChatId(message.getChatId());
            editMessageReplyMarkup.setReplyMarkup(null);
            wonTelegramBotHandler.editMessageReplyMarkup(editMessageReplyMarkup);
        } else if (message != null && message.isReply() && message.hasText()) {
            WonURI correspondingURI = botContextWrapper.getWonURIForMessageId(message.getReplyToMessage().getMessageId());
            Dataset connectionRDF = getEventListenerContext().getLinkedDataSource().getDataForResource(correspondingURI.getUri());
            Connection con = RdfUtils.findFirst(connectionRDF, x -> new ConnectionModelMapper().fromModel(x));
            Model messageModel = WonRdfUtils.MessageUtils.textMessage(message.getText());
            bus.publish(new ConnectionMessageCommandEvent(con, messageModel));
        }
    }
}

Example 27 with EventListener

use of won.bot.framework.eventbot.listener.EventListener in project webofneeds by researchstudio-sat.

the class BotTrigger method activate.

public synchronized void activate() {
    if (active.get())
        return;
    // make the stop listener
    this.stopListener = new ActionOnFirstEventListener(this.context, new BotTriggerFilter(this), new BaseEventBotAction(BotTrigger.this.context) {

        @Override
        protected void doRun(Event event, EventListener executingListener) throws Exception {
            // unregister all listeners
            BotTrigger.this.context.getEventBus().unsubscribe(BotTrigger.this.startListener);
            BotTrigger.this.context.getEventBus().unsubscribe(BotTrigger.this.stopListener);
            BotTrigger.this.cancelableTask.cancel(true);
            BotTrigger.this.active.set(false);
        }
    });
    // make the start listener
    this.startListener = new ActionOnFirstEventListener(this.context, new BotTriggerFilter(this), new BaseEventBotAction(BotTrigger.this.context) {

        @Override
        protected void doRun(Event event, EventListener executingListener) throws Exception {
            reschedule();
        }
    });
    // register both listeners
    context.getEventBus().subscribe(StopBotTriggerCommandEvent.class, stopListener);
    context.getEventBus().subscribe(StartBotTriggerCommandEvent.class, startListener);
    active.set(true);
}

Example 28 with EventListener

use of won.bot.framework.eventbot.listener.EventListener in project webofneeds by researchstudio-sat.

the class CoordinationBehaviour method onActivate.

@Override
protected void onActivate(Optional<Object> message) {
    EventBotAction actionToExecute = null;
    if (typeB == CoordinationType.ACTIVATE) {
        actionToExecute = new BaseEventBotAction(context) {

            @Override
            protected void doRun(Event event, EventListener executingListener) throws Exception {
                BotBehaviourEvent botBehaviourEvent = (BotBehaviourEvent) event;
                behaviourB.activate(botBehaviourEvent.getMessage());
                deactivate(botBehaviourEvent.getMessage());
            }
        };
    } else {
        actionToExecute = new BaseEventBotAction(context) {

            @Override
            protected void doRun(Event event, EventListener executingListener) throws Exception {
                BotBehaviourEvent botBehaviourEvent = (BotBehaviourEvent) event;
                behaviourB.deactivate(botBehaviourEvent.getMessage());
                deactivate(botBehaviourEvent.getMessage());
            }
        };
    }
    Class<? extends Event> eventClazz = null;
    if (typeA == CoordinationType.ACTIVATE) {
        eventClazz = BotBehaviourActivatedEvent.class;
    } else {
        eventClazz = BotBehaviourDeactivatedEvent.class;
    }
    subscribeWithAutoCleanup(eventClazz, new ActionOnEventListener(context, new EventFilter() {

        @Override
        public boolean accept(Event event) {
            return ((BotBehaviourEvent) event).getBehaviour() == behaviourA;
        }
    }, actionToExecute));
}

Example 29 with EventListener

use of won.bot.framework.eventbot.listener.EventListener in project webofneeds by researchstudio-sat.

the class CommentBot method initializeEventListeners.

@Override
protected void initializeEventListeners() {
    EventListenerContext ctx = getEventListenerContext();
    final EventBus bus = getEventBus();
    CommentBotContextWrapper botContextWrapper = (CommentBotContextWrapper) getBotContextWrapper();
    // create needs every trigger execution until 2 needs are created
    this.needCreator = new ActionOnEventListener(ctx, new CreateNeedWithFacetsAction(ctx, botContextWrapper.getNeedCreateListName()), NO_OF_NEEDS);
    bus.subscribe(ActEvent.class, this.needCreator);
    // count until 1 need is created, then create a comment facet
    this.commentFacetCreator = new ActionOnEventListener(ctx, new CreateNeedWithFacetsAction(ctx, botContextWrapper.getCommentListName(), FacetType.CommentFacet.getURI()), 1);
    bus.subscribe(NeedCreatedEvent.class, this.commentFacetCreator);
    this.needConnector = new ActionOnceAfterNEventsListener(ctx, 2, new ConnectFromListToListAction(ctx, botContextWrapper.getNeedCreateListName(), botContextWrapper.getCommentListName(), FacetType.OwnerFacet.getURI(), FacetType.CommentFacet.getURI(), MILLIS_BETWEEN_MESSAGES, "Hi, I am the " + "CommentBot."));
    bus.subscribe(NeedCreatedEvent.class, this.needConnector);
    this.autoOpener = new ActionOnEventListener(ctx, new OpenConnectionAction(ctx, "Hi!"));
    bus.subscribe(OpenFromOtherNeedEvent.class, this.autoOpener);
    bus.subscribe(ConnectFromOtherNeedEvent.class, this.autoOpener);
    BaseEventListener assertionRunner = new ActionOnceAfterNEventsListener(ctx, 1, new BaseEventBotAction(ctx) {

        @Override
        protected void doRun(final Event event, EventListener executingListener) throws Exception {
            executeAssertionsForEstablishedConnectionInternal(bus);
        }
    });
    bus.subscribe(OpenFromOtherNeedEvent.class, assertionRunner);
    // deactivate all needs when the assertion was executed
    this.allNeedsDeactivator = new ActionOnEventListener(ctx, new DeactivateAllNeedsAction(ctx), 1);
    bus.subscribe(AssertionsExecutedEvent.class, this.allNeedsDeactivator);
    // add a listener that counts two NeedDeactivatedEvents and then tells the
    // framework that the bot's work is done
    this.workDoneSignaller = new ActionOnceAfterNEventsListener(ctx, 2, new SignalWorkDoneAction(ctx));
    bus.subscribe(NeedDeactivatedEvent.class, this.workDoneSignaller);
}

Example 30 with EventListener

use of won.bot.framework.eventbot.listener.EventListener in project webofneeds by researchstudio-sat.

the class ConversationBot method initializeEventListeners.

@Override
protected void initializeEventListeners() {
    EventListenerContext ctx = getEventListenerContext();
    EventBus bus = getEventBus();
    // create needs every trigger execution until 2 needs are created
    this.needCreator = new ActionOnEventListener(ctx, new CreateNeedWithFacetsAction(ctx, getBotContextWrapper().getNeedCreateListName()), NO_OF_NEEDS);
    bus.subscribe(ActEvent.class, this.needCreator);
    // count until 2 needs were created, then
    // * connect the 2 needs
    this.needConnector = new ActionOnceAfterNEventsListener(ctx, "needConnector", NO_OF_NEEDS, new ConnectFromListToListAction(ctx, ctx.getBotContextWrapper().getNeedCreateListName(), ctx.getBotContextWrapper().getNeedCreateListName(), FacetType.OwnerFacet.getURI(), FacetType.OwnerFacet.getURI(), MILLIS_BETWEEN_MESSAGES, "Hi, I am the ConversationBot."));
    bus.subscribe(NeedCreatedEvent.class, this.needConnector);
    // add a listener that is informed of the connect/open events and that auto-opens
    // subscribe it to:
    // * connect events - so it responds with open
    // * open events - so it responds with open (if the open received was the first open, and we still need to accept the connection)
    this.autoOpener = new ActionOnEventListener(ctx, new OpenConnectionAction(ctx, "Hi, I " + "am the ConversationBot, too!"));
    bus.subscribe(ConnectFromOtherNeedEvent.class, this.autoOpener);
    // add a listener that auto-responds to messages by a message
    // after 10 messages, it unsubscribes from all events
    // subscribe it to:
    // * message events - so it responds
    // * open events - so it initiates the chain reaction of responses
    this.autoResponder = new AutomaticMessageResponderListener(ctx, NO_OF_MESSAGES, MILLIS_BETWEEN_MESSAGES);
    bus.subscribe(OpenFromOtherNeedEvent.class, this.autoResponder);
    bus.subscribe(MessageFromOtherNeedEvent.class, this.autoResponder);
    // add a listener that closes the connection after it has seen 10 messages
    this.connectionCloser = new ActionOnceAfterNEventsListener(ctx, NO_OF_MESSAGES, new CloseConnectionAction(ctx, "Bye!"));
    bus.subscribe(MessageFromOtherNeedEvent.class, this.connectionCloser);
    // add a listener that closes the connection when a failureEvent occurs
    EventListener onFailureConnectionCloser = new ActionOnEventListener(ctx, new CloseConnectionAction(ctx, "Bye!"));
    bus.subscribe(FailureResponseEvent.class, onFailureConnectionCloser);
    // add a listener that auto-responds to a close message with a deactivation of both needs.
    // subscribe it to:
    // * close events
    this.needDeactivator = new ActionOnEventListener(ctx, new DeactivateAllNeedsAction(ctx), 1);
    bus.subscribe(CloseFromOtherNeedEvent.class, this.needDeactivator);
    // add a listener that counts two NeedDeactivatedEvents and then tells the
    // framework that the bot's work is done
    this.workDoneSignaller = new ActionOnceAfterNEventsListener(ctx, NO_OF_NEEDS, new SignalWorkDoneAction(ctx));
    bus.subscribe(NeedDeactivatedEvent.class, this.workDoneSignaller);
}