Examples with Rule org.openhab.core.automation.Rule used on opensource projects

Example 16 with Rule

use of org.openhab.core.automation.Rule in project openhab-core by openhab.

the class RuleRegistryImpl method added.

@Override
public void added(Provider<Rule> provider, Rule element) {
    String ruleUID = element.getUID();
    Rule resolvedRule = element;
    try {
        resolvedRule = resolveRuleByTemplate(element);
    } catch (IllegalArgumentException e) {
        logger.debug("Added rule '{}' is invalid", ruleUID, e);
    }
    super.added(provider, element);
    if (element != resolvedRule) {
        if (provider instanceof ManagedRuleProvider) {
            update(resolvedRule);
        } else {
            super.updated(provider, element, resolvedRule);
        }
    }
}

Example 17 with Rule

use of org.openhab.core.automation.Rule in project openhab-core by openhab.

the class RuleRegistryTest method testAddRetrieveRules.

/**
 * test adding and retrieving rules
 */
@Test
public void testAddRetrieveRules() {
    final String tag1 = "tag1";
    final String tag2 = "tag2";
    final String tag3 = "tag3";
    Set<String> tags;
    String name;
    Rule addedRule;
    Rule getRule;
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // checking RuleRegistry
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    assertEquals(0, ruleRegistry.getAll().size(), "RuleImpl list size");
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // checking rule without tag
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    name = "rule_without_tag";
    final RuleImpl ruleWithoutTag = new RuleImpl(name);
    addedRule = ruleRegistry.add(ruleWithoutTag);
    assertNotNull(addedRule, "RuleImpl for:" + name);
    getRule = ruleRegistry.get(name);
    assertNotNull(getRule, "RuleImpl for:" + name);
    assertEquals(1, ruleRegistry.getAll().size(), "RuleImpl list size");
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // checking that results from stream() have the same size as getAll() above
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    assertEquals(1, ruleRegistry.stream().collect(Collectors.toList()).size(), "RuleImpl list size");
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // checking predicates
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    assertEquals(1, ruleRegistry.stream().filter(hasNoTags()).collect(Collectors.toList()).size(), "RuleImpl list size");
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // checking rule with 1 tag
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    name = "rule_with_tag1";
    tags = new HashSet<>();
    tags.add(tag1);
    final RuleImpl ruleWithTag1 = new RuleImpl(name);
    ruleWithTag1.setTags(tags);
    addedRule = ruleRegistry.add(ruleWithTag1);
    assertNotNull(addedRule, "RuleImpl for:" + name);
    getRule = ruleRegistry.get(name);
    assertNotNull(getRule, "RuleImpl for:" + name);
    assertEquals(2, ruleRegistry.getAll().size(), "RuleImpl list size");
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // checking that results from stream() have the same size as getAll() above
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    assertEquals(2, ruleRegistry.stream().collect(Collectors.toList()).size(), "RuleImpl list size");
    Collection<Rule> rulesWithTag1 = ruleRegistry.getByTags(tag1);
    assertEquals(1, rulesWithTag1.size(), "RuleImpl list size");
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // checking predicates
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    assertEquals(1, ruleRegistry.stream().filter(hasNoTags()).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(1, ruleRegistry.stream().filter(hasAnyOfTags(tags)).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(1, ruleRegistry.stream().filter(hasAnyOfTags(tag1)).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(1, ruleRegistry.stream().filter(hasAllTags(tags)).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(1, ruleRegistry.stream().filter(hasAllTags(tag1)).collect(Collectors.toList()).size(), "RuleImpl list size");
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // checking rule with 2 tags
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    name = "rule_with_tag1_tag2";
    tags = new HashSet<>();
    tags.add(tag1);
    tags.add(tag2);
    final RuleImpl ruleWithTag1Tag2 = new RuleImpl(name);
    ruleWithTag1Tag2.setTags(tags);
    addedRule = ruleRegistry.add(ruleWithTag1Tag2);
    assertNotNull(addedRule, "RuleImpl for:" + name);
    getRule = ruleRegistry.get(name);
    assertNotNull(getRule, "RuleImpl for:" + name);
    assertEquals(3, ruleRegistry.getAll().size(), "RuleImpl list size");
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // checking that results from stream() have the same size as getAll() above
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    assertEquals(3, ruleRegistry.stream().collect(Collectors.toList()).size(), "RuleImpl list size");
    rulesWithTag1 = ruleRegistry.getByTags(tag1);
    assertEquals(2, rulesWithTag1.size(), "RuleImpl list size");
    Collection<Rule> rulesWithTag2 = ruleRegistry.getByTags(tag2);
    assertEquals(1, rulesWithTag2.size(), "RuleImpl list size");
    Collection<Rule> rulesWithAllOfTag1Tag2 = ruleRegistry.getByTags(tag1, tag2);
    assertEquals(1, rulesWithAllOfTag1Tag2.size(), "RuleImpl list size");
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // checking predicates
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    assertEquals(1, ruleRegistry.stream().filter(hasNoTags()).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(2, ruleRegistry.stream().filter(hasAnyOfTags(tags)).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(2, ruleRegistry.stream().filter(hasAnyOfTags(tag1)).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(2, ruleRegistry.stream().filter(hasAnyOfTags(tag1, tag2)).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(1, ruleRegistry.stream().filter(hasAnyOfTags(tag2)).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(1, ruleRegistry.stream().filter(hasAnyOfTags(tag1).and(hasAnyOfTags(tag2))).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(2, ruleRegistry.stream().filter(hasAllTags(tag1)).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(1, ruleRegistry.stream().filter(hasAllTags(tags)).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(1, ruleRegistry.stream().filter(hasAllTags(tag1, tag2)).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(1, ruleRegistry.stream().filter(hasAllTags(tag2)).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(1, ruleRegistry.stream().filter(hasAllTags(tag1).and(hasAllTags(tag2))).collect(Collectors.toList()).size(), "RuleImpl list size");
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // checking rule with 3 tags
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    name = "rule_with_tag1_tag2_tag3";
    tags = new HashSet<>();
    tags.add(tag1);
    tags.add(tag2);
    tags.add(tag3);
    final RuleImpl ruleWithTag1Tag2Tag3 = new RuleImpl("rule_with_tag1_tag2_tag3");
    ruleWithTag1Tag2Tag3.setTags(tags);
    addedRule = ruleRegistry.add(ruleWithTag1Tag2Tag3);
    assertNotNull(addedRule, "RuleImpl for:" + name);
    getRule = ruleRegistry.get(name);
    assertNotNull(getRule, "RuleImpl for:" + name);
    assertEquals(4, ruleRegistry.getAll().size(), "RuleImpl list size");
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // checking that results from stream() have the same size as getAll() above
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    assertEquals(4, ruleRegistry.stream().collect(Collectors.toList()).size(), "RuleImpl list size");
    rulesWithTag1 = ruleRegistry.getByTags(tag1);
    assertEquals(3, rulesWithTag1.size(), "RuleImpl list size");
    rulesWithTag2 = ruleRegistry.getByTags(tag2);
    assertEquals(2, rulesWithTag2.size(), "RuleImpl list size");
    Collection<Rule> rulesWithTag3 = ruleRegistry.getByTags(tag3);
    assertEquals(1, rulesWithTag3.size(), "RuleImpl list size");
    rulesWithAllOfTag1Tag2 = ruleRegistry.getByTags(tag1, tag2);
    assertEquals(2, rulesWithAllOfTag1Tag2.size(), "RuleImpl list size");
    Collection<Rule> rulesWithAllTag1Tag3 = ruleRegistry.getByTags(tag1, tag3);
    assertEquals(1, rulesWithAllTag1Tag3.size(), "RuleImpl list size");
    Collection<Rule> rulesWithAllOfTag1Tag2Tag3 = ruleRegistry.getByTags(tag1, tag2, tag3);
    assertEquals(1, rulesWithAllOfTag1Tag2Tag3.size(), "RuleImpl list size");
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // checking predicates
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    assertEquals(1, ruleRegistry.stream().filter(hasNoTags()).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(3, ruleRegistry.stream().filter(hasAnyOfTags(tags)).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(3, ruleRegistry.stream().filter(hasAnyOfTags(tag1)).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(3, ruleRegistry.stream().filter(hasAnyOfTags(tag1, tag2)).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(3, ruleRegistry.stream().filter(hasAnyOfTags(tag1, tag2, tag3)).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(2, ruleRegistry.stream().filter(hasAnyOfTags(tag2)).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(2, ruleRegistry.stream().filter(hasAnyOfTags(tag2, tag3)).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(2, ruleRegistry.stream().filter(hasAnyOfTags(tag1).and(hasAnyOfTags(tag2))).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(1, ruleRegistry.stream().filter(hasAnyOfTags(tag1).and(hasAnyOfTags(tag3))).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(1, ruleRegistry.stream().filter(hasAnyOfTags(tag2).and(hasAnyOfTags(tag3))).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(1, ruleRegistry.stream().filter(hasAnyOfTags(tag3)).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(3, ruleRegistry.stream().filter(hasAllTags(tag1)).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(2, ruleRegistry.stream().filter(hasAllTags(tag2)).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(2, ruleRegistry.stream().filter(hasAllTags(tag1, tag2)).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(1, ruleRegistry.stream().filter(hasAllTags(tags)).collect(Collectors.toList()).size(), "RuleImpl list size");
    assertEquals(1, ruleRegistry.stream().filter(hasAllTags(tag1, tag2, tag3)).collect(Collectors.toList()).size(), "RuleImpl list size");
}

Example 18 with Rule

use of org.openhab.core.automation.Rule in project openhab-core by openhab.

the class AutomationIntegrationJsonTest method assertThatARuleFromJsonFileIsAddedAutomaticallyAndTheRuntimeRuleHasResolvedModuleReferences.

@Test
public void assertThatARuleFromJsonFileIsAddedAutomaticallyAndTheRuntimeRuleHasResolvedModuleReferences() {
    logger.info("assert that a rule from json file is added automatically and the runtime rule has resolved module references");
    // WAIT until Rule modules types are parsed and the rule becomes IDLE
    waitForAssert(() -> {
        assertThat(ruleRegistry.getAll().isEmpty(), is(false));
        Optional<Rule> rule2 = ruleRegistry.stream().filter(RulePredicates.hasAllTags("jsonTest", "references")).findFirst();
        assertThat(rule2.isPresent(), is(true));
        RuleStatusInfo ruleStatus2 = ruleManager.getStatusInfo(rule2.get().getUID());
        assertThat(ruleStatus2.getStatus(), is(RuleStatus.IDLE));
    }, 10000, 200);
    Optional<Rule> optionalRule = ruleRegistry.stream().filter(RulePredicates.hasAllTags("jsonTest", "references")).findFirst();
    assertThat(optionalRule.isPresent(), is(true));
    Rule rule = optionalRule.get();
    assertThat(rule.getName(), is("ItemSampleRuleWithReferences"));
    assertTrue(rule.getTags().contains("sample"));
    assertTrue(rule.getTags().contains("item"));
    assertTrue(rule.getTags().contains("rule"));
    assertTrue(rule.getTags().contains("references"));
    Optional<? extends Trigger> trigger = rule.getTriggers().stream().filter(t -> "ItemStateChangeTriggerID".equals(t.getId())).findFirst();
    assertThat(trigger.isPresent(), is(true));
    assertThat(trigger.get().getTypeUID(), is("core.GenericEventTrigger"));
    assertThat(trigger.get().getConfiguration().get("eventTopic"), is("openhab/items/*"));
    assertThat(trigger.get().getConfiguration().get("eventTypes"), is("ItemStateEvent"));
    Optional<? extends Action> action = rule.getActions().stream().filter(a -> "ItemPostCommandActionID".equals(a.getId())).findFirst();
    assertThat(action.isPresent(), is(true));
    assertThat(action.get().getTypeUID(), is("core.ItemCommandAction"));
    assertThat(action.get().getConfiguration().get("command"), is("ON"));
    RuleStatusInfo ruleStatus = ruleManager.getStatusInfo(rule.getUID());
    assertThat(ruleStatus.getStatus(), is(RuleStatus.IDLE));
    // run the rule to check if the runtime rule has resolved module references and is executed successfully
    EventPublisher eventPublisher = getService(EventPublisher.class);
    @NonNullByDefault EventSubscriber itemEventHandler = new EventSubscriber() {

        @Override
        public Set<String> getSubscribedEventTypes() {
            return Set.of(ItemCommandEvent.TYPE);
        }

        @Override
        @Nullable
        public EventFilter getEventFilter() {
            return null;
        }

        @Override
        public void receive(Event e) {
            logger.info("Event: {}", e.getTopic());
            if (e.getTopic().contains("myLampItem")) {
                itemEvent = e;
            }
        }
    };
    registerService(itemEventHandler);
    eventPublisher.post(ItemEventFactory.createStateEvent("myMotionItem", OnOffType.ON));
    waitForAssert(() -> {
        assertThat(itemEvent, is(notNullValue()));
    }, 3000, 100);
    assertThat(itemEvent.getTopic(), is(equalTo("openhab/items/myLampItem/command")));
    assertThat(((ItemCommandEvent) itemEvent).getItemCommand(), is(OnOffType.ON));
}

Example 19 with Rule

use of org.openhab.core.automation.Rule in project openhab-core by openhab.

the class RunRuleModuleTest method sceneActivatedByRule.

@Test
public void sceneActivatedByRule() throws ItemNotFoundException, InterruptedException {
    final RuleRegistry ruleRegistry = getService(RuleRegistry.class);
    final RuleManager ruleEngine = getService(RuleManager.class);
    assertNotNull(ruleRegistry);
    // Scene rule
    final Rule sceneRule = createSceneRule();
    logger.info("SceneRule created: {}", sceneRule.getUID());
    ruleRegistry.add(sceneRule);
    ruleEngine.setEnabled(sceneRule.getUID(), true);
    waitForAssert(() -> {
        assertEquals(RuleStatus.IDLE, ruleEngine.getStatusInfo(sceneRule.getUID()).getStatus());
    });
    // Outer rule
    final Rule outerRule = createOuterRule();
    logger.info("SceneActivationRule created: {}", outerRule.getUID());
    ruleRegistry.add(outerRule);
    ruleEngine.setEnabled(outerRule.getUID(), true);
    waitForAssert(() -> {
        assertEquals(RuleStatus.IDLE, ruleEngine.getStatusInfo(outerRule.getUID()).getStatus());
    });
    // Test rule
    final EventPublisher eventPublisher = getService(EventPublisher.class);
    assertNotNull(eventPublisher);
    final ItemRegistry itemRegistry = getService(ItemRegistry.class);
    assertNotNull(itemRegistry);
    final Queue<Event> events = new LinkedList<>();
    subscribeToEvents(ItemCommandEvent.TYPE, events);
    // trigger rule by switching triggerItem ON
    eventPublisher.post(ItemEventFactory.createStateEvent("ruleTrigger", OnOffType.ON));
    waitForAssert(() -> {
        assertFalse(events.isEmpty());
        ItemCommandEvent event = (ItemCommandEvent) events.remove();
        assertEquals("openhab/items/switch3/command", event.getTopic());
        assertEquals(OnOffType.ON, event.getItemCommand());
    });
}

Example 20 with Rule

use of org.openhab.core.automation.Rule in project openhab-core by openhab.

the class RunRuleModuleTest method createSceneRule.

private Rule createSceneRule() {
    final Configuration sceneRuleAction1Config = new Configuration(Map.ofEntries(entry("itemName", "switch1"), entry("command", "ON")));
    final Configuration sceneRuleAction2Config = new Configuration(Map.ofEntries(entry("itemName", "switch2"), entry("command", "ON")));
    final Configuration sceneRuleAction3Config = new Configuration(Map.ofEntries(entry("itemName", "switch3"), entry("command", "ON")));
    final Rule sceneRule = RuleBuilder.create("exampleSceneRule").withActions(ModuleBuilder.createAction().withId("sceneItemPostCommandAction1").withTypeUID("core.ItemCommandAction").withConfiguration(sceneRuleAction1Config).build(), ModuleBuilder.createAction().withId("sceneItemPostCommandAction2").withTypeUID("core.ItemCommandAction").withConfiguration(sceneRuleAction2Config).build(), ModuleBuilder.createAction().withId("sceneItemPostCommandAction3").withTypeUID("core.ItemCommandAction").withConfiguration(sceneRuleAction3Config).build()).withName("Example Scene").build();
    return sceneRule;
}