def create_switch_trigger_item(item_name, logger):
"""Checks to see if the passed in Item exists and if it doesn't creates it
as a Switch Item.
Arguments:
- item_name: the name of the Item to create
- logger: used to log out informational statement
Returns:
True if the Item was created or it exists already and it's the right
type. False otherwise.
"""
if item_name not in scope.items:
from core.items import add_item
logger.info("Creating Item {}".format(item_name))
add_item(item_name, item_type="Switch")
return True
# TODO: figure out how to test the Item's type.
# if not isinstance(scope.ir.getItem(item_name),
# (scope.SwitchItem,
# scope.DimmerItem,
# scope.ColorItem)):
# logger.error("Item {} already exists but it can't receive ON commands"
# .format(item_name))
# return False
else:
return True
def process_pickupdates(dates, type, description, item, now=None):
if not dates or len(dates) == 0:
return
pickup_dates = [x['date'] for x in dates if x['type'] == type]
if pickup_dates.empty():
return
if now is None:
now = datetime.now()
send_trash_pickup_notifications.log.debug(u"Processing pickup dates for {}: {} and item {} on {}".format(type, description, item, now))
if itemRegistry.getItems(item) == []:
if afvalkalender_configuration['create_missing_items']:
add_item(item, item_type="DateTime", label="{} [%%1$td-%1$tm]".format(description), category="Calendar", groups=[], tags=[])
else:
return
today = str(now.date())
tomorrow = str(now.date() + timedelta(days=1))
next_date = next((d for d in pickup_dates if d >= today), pickup_dates[-1])
next_date_list = next_date.split("-")
pickup_date = DateTimeType().zonedDateTime.withYear(int(next_date_list[0])).withMonth(int(next_date_list[1])).withDayOfMonth(int(next_date_list[2])).withHour(0).withMinute(0).withSecond(0).withNano(0)
post_update(item, str(pickup_date))
current_time = now.time()
if today == next_date and current_time.hour <= 12:
message = u"Vandaag wordt het {} opgehaald.".format(description)
send_trash_pickup_notifications.log.info(message)
notification(message)
if tomorrow == next_date and current_time.hour > 12:
message = u"Morgen wordt het {} opgehaald.".format(description)
send_trash_pickup_notifications.log.info(message)
notification(message)
def addDayModeItem():
addDayModeItem.log = logging.getLogger("{}.addDayModeItem".format(LOG_PREFIX))
# scriptExtension.importPreset("RuleSupport")
try:
if ir.getItems("Day_Mode") == []:
add_item("Day_Mode",
item_type="String",
groups=["gAstro,gPersist"],
label="Current day mode [%s]",
category="sunset",
tags=["Astro"]
)
except:
import traceback
addDayModeItem.log.error(traceback.format_exc())
def addWatchdogItems():
"""
Create the Watchdog Items and Group if they don't exist yet.
"""
global logTitle
# Add Watchdog Group if it doesn't exist
if ir.getItems(WATCHDOG_GROUP) == []:
LogAction.logInfo(logTitle, u"Create Group [{}]".format(WATCHDOG_GROUP))
add_item(WATCHDOG_GROUP, item_type="Group", label="Watchdog Items Group", tags=["Watchdog"])
try:
for entry in keyThingsDict.values():
wdItemName = entry.get("status_item")
if ir.getItems(wdItemName) == []:
add_item(wdItemName, item_type="String", groups=[WATCHDOG_GROUP], label=entry.get("thing_name"), tags=["Watchdog"])
LogAction.logInfo(logTitle, u"Created item [{}] in Group [{}]".format(wdItemName, WATCHDOG_GROUP))
except:
import traceback
LogAction.logError(logTitle, u"{}".format(traceback.format_exc()))
def addGrafanaItems():
addGrafanaItems.log = logging.getLogger(
"{}.addGrafanaItems".format(LOG_PREFIX))
# scriptExtension.importPreset("RuleSupport")
# Add Grafana Group if it doesn't exist
if ir.getItems(GRAFANA_GROUP) == []:
addGrafanaItems.log.info("Create Group [{}]".format(GRAFANA_GROUP))
add_item(GRAFANA_GROUP,
item_type="Group",
label="Grafana Snapshot images",
tags=["Grafana"])
try:
for entry in grafImgDict.values():
imgItemName = entry.get("item_name")
if ir.getItems(imgItemName) == []:
add_item(imgItemName,
item_type="Image",
groups=[GRAFANA_GROUP],
label=entry.get("item_description"),
tags=["Grafana"])
grafanaChannel = "ftpupload:imagereceiver:ftp_" + imgItemName + ":image"
addGrafanaItems.log.info(
"Created item [{}], link channel [{}]".format(
imgItemName, grafanaChannel))
add_link(imgItemName, ChannelUID(grafanaChannel))
set_metadata(imgItemName, "Grafana_Graphs", \
{"PanelId": entry.get("grafana_panelid"), \
"RefreshRate": entry.get("image_refresh"), \
"RangeFrom": entry.get("grafana_range_from"), \
"RangeTo": entry.get("grafana_range_to"), \
"Theme": entry.get("grafana_theme"), \
"LastRefresh": entry.get("last_refresh")}, overwrite=True)
addGrafanaItems.log.info("Metadata set [{}] [{}] [{}] [{}]".format(
get_key_value(imgItemName, "Grafana_Graphs", "PanelId"),
get_key_value(imgItemName, "Grafana_Graphs", "RefreshRate"),
get_key_value(imgItemName, "Grafana_Graphs", "Theme"),
get_key_value(imgItemName, "Grafana_Graphs", "LastRefresh")))
except:
import traceback
addGrafanaItems.log.error(traceback.format_exc())
def addSunriseItems():
addSunriseItems.log = logging.getLogger(
"{}.addSunriseItems".format(LOG_PREFIX))
# scriptExtension.importPreset("RuleSupport")
try:
if ir.getItems("Astro_Sun_SetTomorrow") == []:
add_item("Astro_Sun_SetTomorrow",
item_type="DateTime",
groups=["gAstro"],
label="Tomorrow's Sunset [%1$tH:%1$tM]",
category="sunset",
tags=["Astro"])
if ir.getItems("Astro_Sun_RiseTomorrow") == []:
add_item("Astro_Sun_RiseTomorrow",
item_type="DateTime",
groups=["gAstro"],
label="Tomorrow's Sunrise [%1$tH:%1$tM]",
category="sunrise",
tags=["Astro"])
if ir.getItems("Astro_Sun_SetNext") == []:
add_item("Astro_Sun_SetNext",
item_type="DateTime",
groups=["gAstro"],
label="Zonsondergang [%1$tH:%1$tM]",
category="sunset",
tags=["Astro"])
if ir.getItems("Astro_Sun_RiseNext") == []:
add_item("Astro_Sun_RiseNext",
item_type="DateTime",
groups=["gAstro"],
label="Zonsopkomst [%1$tH:%1$tM]",
category="sunrise",
tags=["Astro"])
except:
import traceback
addSunriseItems.log.error(traceback.format_exc())
* Manual Thing configurations (e.q., location, name, etc.) are not retained
and restored.
"""
from time import sleep
from core.rules import rule
from core.triggers import when
from core.actions import Exec
from core.items import add_item
from core.metadata import set_value
if not itemRegistry.getItems("Delete_Zwave_Things"):
add_item("Delete_Zwave_Things",
item_type="Switch",
label="Delete Z-Wave Things [%s]",
category="Error",
tags=["Switchable"])
set_value("Delete_Zwave_Things", "autoupdate", "false")
@rule("Misc: Delete and rediscover Z-Wave Things")
@when("Item Delete_Zwave_Things received command")
def deleteRediscoverZwaveThings(event):
deleteRediscoverZwaveThings.log.debug("Delete Z-Wave Things: Start")
statusMap = {
"DeletionSuccess": 0,
"DeletionFailure": 0,
"DiscoveryFailure": 0,
"ThingsAdded": 0,
def addOWMItems():
addOWMItems.log = logging.getLogger(LOG_PREFIX + ".addOWMItems")
# create OWM Items and groups, if they do not exist
from org.eclipse.smarthome.core.thing import ThingTypeUID
from org.eclipse.smarthome.core.thing import ChannelUID
from org.eclipse.smarthome.config.core import Configuration
from org.eclipse.smarthome.core.library.types import ArithmeticGroupFunction
from core.items import add_item
from core.links import add_link
owmThingUID = None
for thing in things.getAll():
if thing.getThingTypeUID() == ThingTypeUID("openweathermap:weather-and-forecast"):
if str(thing.statusInfo) == "ONLINE":
thingConfiguration = thing.getConfiguration()
forecastHours = thingConfiguration.get("forecastHours")
if str(forecastHours) == "120":
forecastDays = thingConfiguration.get("forecastDays")
if str(forecastDays) == "0":
owmThingUID = str(thing.getUID())
break
else:
addOWMItems.log.warn("Thing found, but forecastDays is not set to [0]: forecastDays=[{}]".format(forecastDays))
else:
addOWMItems.log.warn("Thing found, but forecastHours is not set to [120]: forecastHours=[{}]".format(forecastHours))
else:
addOWMItems.log.warn("Thing found, but statusInfo was not [ONLINE]: statusInfo=[{}]".format(thing.statusInfo))
if owmThingUID is None:
addOWMItems.log.warn("No Thing found with ThingTypeUID 'openweathermap:weather-and-forecast', or it was not ONLINE, or it was improperly configured for the free API. Exiting script.")
else:
addOWMItems.log.debug("owmThingUID set to [{}]".format(owmThingUID))
# install Scale transformation service, if not already
from org.eclipse.smarthome.model.script.actions.Exec import executeCommandLine
import json
scaleCheckResult = json.loads(executeCommandLine("/bin/sh@@-c@@/usr/bin/curl -s --connect-timeout 10 -m 10 -X GET -H \"Accept: application/json\" \"http://*****:*****@@-c@@/usr/bin/curl -o /dev/null -s -w \"%{http_code}\" --connect-timeout 10 -m 10 -X POST -H \"Content-Type: application/json\" -H \"Accept: application/json\" \"http://*****:*****@rule("Add OpenWeatherMap Items to daily forecast groups")
@when("Item Current_Timestamp changed")
def addOWMItemsToGroups(event):
# remove hourly forecast Items from groups
for groupIndex in range(1, 6):
for member in filter(lambda item: "Current" not in item.name, ir.getItem("gForecast_Timestamp_{}".format(groupIndex)).getMembers()):
ir.getItem("gForecast_Timestamp_{}".format(groupIndex)).removeMember(member)
for member in filter(lambda item: "Current" not in item.name, ir.getItem("gForecast_Condition_{}".format(groupIndex)).getMembers()):
ir.getItem("gForecast_Condition_{}".format(groupIndex)).removeMember(member)
for member in filter(lambda item: "Current" not in item.name, ir.getItem("gForecast_ConditionID_{}".format(groupIndex)).getMembers()):
ir.getItem("gForecast_ConditionID_{}".format(groupIndex)).removeMember(member)
for member in filter(lambda item: "Current" not in item.name, ir.getItem("gForecast_IconID_{}".format(groupIndex)).getMembers()):
ir.getItem("gForecast_IconID_{}".format(groupIndex)).removeMember(member)
for member in filter(lambda item: "Current" not in item.name, ir.getItem("gForecast_Icon_{}".format(groupIndex)).getMembers()):
ir.getItem("gForecast_Icon_{}".format(groupIndex)).removeMember(member)
for member in filter(lambda item: "Current" not in item.name, ir.getItem("gForecast_Temperature_High_{}".format(groupIndex)).getMembers()):
ir.getItem("gForecast_Temperature_High_{}".format(groupIndex)).removeMember(member)
for member in filter(lambda item: "Current" not in item.name, ir.getItem("gForecast_Temperature_Low_{}".format(groupIndex)).getMembers()):
ir.getItem("gForecast_Temperature_Low_{}".format(groupIndex)).removeMember(member)
for member in filter(lambda item: "Current" not in item.name, ir.getItem("gForecast_Pressure_{}".format(groupIndex)).getMembers()):
ir.getItem("gForecast_Pressure_{}".format(groupIndex)).removeMember(member)
for member in filter(lambda item: "Current" not in item.name, ir.getItem("gForecast_Humidity_{}".format(groupIndex)).getMembers()):
ir.getItem("gForecast_Humidity_{}".format(groupIndex)).removeMember(member)
for member in filter(lambda item: "Current" not in item.name, ir.getItem("gForecast_WindSpeed_{}".format(groupIndex)).getMembers()):
ir.getItem("gForecast_WindSpeed_{}".format(groupIndex)).removeMember(member)
for member in filter(lambda item: "Current" not in item.name, ir.getItem("gForecast_GustSpeed_{}".format(groupIndex)).getMembers()):
ir.getItem("gForecast_GustSpeed_{}".format(groupIndex)).removeMember(member)
for member in filter(lambda item: "Current" not in item.name, ir.getItem("gForecast_WindDirection_{}".format(groupIndex)).getMembers()):
ir.getItem("gForecast_WindDirection_{}".format(groupIndex)).removeMember(member)
for member in filter(lambda item: "Current" not in item.name, ir.getItem("gForecast_Cloudiness_{}".format(groupIndex)).getMembers()):
ir.getItem("gForecast_Cloudiness_{}".format(groupIndex)).removeMember(member)
for member in filter(lambda item: "Current" not in item.name, ir.getItem("gForecast_RainVolume_{}".format(groupIndex)).getMembers()):
ir.getItem("gForecast_RainVolume_{}".format(groupIndex)).removeMember(member)
for member in filter(lambda item: "Current" not in item.name, ir.getItem("gForecast_SnowVolume_{}".format(groupIndex)).getMembers()):
ir.getItem("gForecast_SnowVolume_{}".format(groupIndex)).removeMember(member)
# update group labels to reflect week day
from org.joda.time import DateTime
import calendar
lastReading = DateTime(str(items["Current_Timestamp"])).getDayOfWeek() - 1
for index in range(1, 6):
dayOfWeek = "Today" if index == 1 else calendar.day_name[(lastReading + index - 1) % 7]
ir.getItem("gForecast_" + str(index)).setLabel(dayOfWeek)
ir.getItem("gForecast_Timestamp_" + str(index)).setLabel(dayOfWeek + ": Timestamp")
ir.getItem("gForecast_Condition_" + str(index)).setLabel(dayOfWeek + ": Condition [%s]")
ir.getItem("gForecast_ConditionID_" + str(index)).setLabel(dayOfWeek + ": Condition ID [%s]")
ir.getItem("gForecast_IconID_" + str(index)).setLabel(dayOfWeek + ": Icon ID [%s]")
ir.getItem("gForecast_Icon_" + str(index)).setLabel(dayOfWeek + ": Icon")
ir.getItem("gForecast_Temperature_High_" + str(index)).setLabel(dayOfWeek + ": Temperature (high) [%.0f %unit%]")
ir.getItem("gForecast_Temperature_Low_" + str(index)).setLabel(dayOfWeek + ": Temperature (low) [%.0f %unit%]")
ir.getItem("gForecast_Pressure_" + str(index)).setLabel(dayOfWeek + ": Pressure [%.1f %unit%]")
ir.getItem("gForecast_Humidity_" + str(index)).setLabel(dayOfWeek + ": Humidity [%d %unit%]")
ir.getItem("gForecast_WindSpeed_" + str(index)).setLabel(dayOfWeek + ": Wind Speed [%.0f %unit%]")
ir.getItem("gForecast_GustSpeed_" + str(index)).setLabel(dayOfWeek + ": Gust Speed [%.0f %unit%]")
ir.getItem("gForecast_WindDirection_" + str(index)).setLabel(dayOfWeek + ": Wind direction [SCALE(windDirection.scale):%s]")
ir.getItem("gForecast_Cloudiness_" + str(index)).setLabel(dayOfWeek + ": Cloudiness [%d %unit%]")
ir.getItem("gForecast_RainVolume_" + str(index)).setLabel(dayOfWeek + ": Rain Volume [%.1f %unit%]")
ir.getItem("gForecast_SnowVolume_" + str(index)).setLabel(dayOfWeek + ": Snow Volume [%.1f %unit%]")
# add Forecast Items to groups, and update the labels to reflect time
groupIndex = 1
for index in range(1, 41):
if DateTime(str(items["Forecast_Timestamp_{:02}".format(3 * index)])).getDayOfWeek() - 1 != (DateTime.now().getDayOfWeek() + groupIndex - 2) % 7:
if groupIndex == 5:
break# we're at the end of the forecasts that fit into 5 days
else:
groupIndex += 1
labelTime = items["Forecast_Timestamp_{:02}".format(3 * index)].format("%1$tl:%1$tM%1$tp")
ir.getItem("gForecast_Timestamp_{}".format(groupIndex)).addMember(ir.getItem("Forecast_Timestamp_{:02d}".format(3 * index)))
ir.getItem("Forecast_Timestamp_{:02d}".format(3 * index)).setLabel("Forecast ({}): Timestamp [%1$tY-%1$tm-%1$td %1$tI:%1$tM%1$tp]".format(labelTime))
ir.getItem("gForecast_Condition_{}".format(groupIndex)).addMember(ir.getItem("Forecast_Condition_{:02d}".format(3 * index)))
ir.getItem("Forecast_Condition_{:02d}".format(3 * index)).setLabel("Forecast ({}): Condition [%s]".format(labelTime))
ir.getItem("gForecast_ConditionID_{}".format(groupIndex)).addMember(ir.getItem("Forecast_ConditionID_{:02d}".format(3 * index)))
ir.getItem("Forecast_ConditionID_{:02d}".format(3 * index)).setLabel("Forecast ({}): Condition ID [%s]".format(labelTime))
ir.getItem("gForecast_IconID_{}".format(groupIndex)).addMember(ir.getItem("Forecast_IconID_{:02d}".format(3 * index)))
ir.getItem("Forecast_IconID_{:02d}".format(3 * index)).setLabel("Forecast ({}): Icon ID [%s]".format(labelTime))
ir.getItem("gForecast_Icon_{}".format(groupIndex)).addMember(ir.getItem("Forecast_Icon_{:02d}".format(3 * index)))
ir.getItem("Forecast_Icon_{:02d}".format(3 * index)).setLabel("Forecast ({}): Icon".format(labelTime))
ir.getItem("gForecast_Temperature_High_{}".format(groupIndex)).addMember(ir.getItem("Forecast_Temperature_{:02d}".format(3 * index)))
ir.getItem("Forecast_Temperature_{:02d}".format(3 * index)).setLabel("Forecast ({}): Temperature [%.0f %unit%]".format(labelTime))
ir.getItem("gForecast_Temperature_Low_{}".format(groupIndex)).addMember(ir.getItem("Forecast_Temperature_{:02d}".format(3 * index)))
ir.getItem("Forecast_Temperature_{:02d}".format(3 * index)).setLabel("Forecast ({}): Temperature [%.0f %unit%]".format(labelTime))
ir.getItem("gForecast_Pressure_{}".format(groupIndex)).addMember(ir.getItem("Forecast_Pressure_{:02d}".format(3 * index)))
ir.getItem("Forecast_Pressure_{:02d}".format(3 * index)).setLabel("Forecast ({}): Pressure [%.1f %unit%]".format(labelTime))
ir.getItem("gForecast_Humidity_{}".format(groupIndex)).addMember(ir.getItem("Forecast_Humidity_{:02d}".format(3 * index)))
ir.getItem("Forecast_Humidity_{:02d}".format(3 * index)).setLabel("Forecast ({}): Humidity [%d %unit%]".format(labelTime))
ir.getItem("gForecast_WindSpeed_{}".format(groupIndex)).addMember(ir.getItem("Forecast_WindSpeed_{:02d}".format(3 * index)))
ir.getItem("Forecast_WindSpeed_{:02d}".format(3 * index)).setLabel("Forecast ({}): Wind speed [%.0f %unit%]".format(labelTime))
ir.getItem("gForecast_GustSpeed_{}".format(groupIndex)).addMember(ir.getItem("Forecast_GustSpeed_{:02d}".format(3 * index)))
ir.getItem("Forecast_GustSpeed_{:02d}".format(3 * index)).setLabel("Forecast ({}): Gust speed [%.0f %unit%]".format(labelTime))
ir.getItem("gForecast_WindDirection_{}".format(groupIndex)).addMember(ir.getItem("Forecast_WindDirection_{:02d}".format(3 * index)))
ir.getItem("Forecast_WindDirection_{:02d}".format(3 * index)).setLabel("Forecast ({}): Wind direction [SCALE(windDirection.scale):%s]".format(labelTime))
ir.getItem("gForecast_Cloudiness_{}".format(groupIndex)).addMember(ir.getItem("Forecast_Cloudiness_{:02d}".format(3 * index)))
ir.getItem("Forecast_Cloudiness_{:02d}".format(3 * index)).setLabel("Forecast ({}): Cloudiness [%d %unit%]".format(labelTime))
ir.getItem("gForecast_RainVolume_{}".format(groupIndex)).addMember(ir.getItem("Forecast_RainVolume_{:02d}".format(3 * index)))
ir.getItem("Forecast_RainVolume_{:02d}".format(3 * index)).setLabel("Forecast ({}): Rain volume [%.1f %unit%]".format(labelTime))
ir.getItem("gForecast_SnowVolume_{}".format(groupIndex)).addMember(ir.getItem("Forecast_SnowVolume_{:02d}".format(3 * index)))
ir.getItem("Forecast_SnowVolume_{:02d}".format(3 * index)).setLabel("Forecast ({}): Snow volume [%.1f %unit%]".format(labelTime))
# set Condition, Icon and WindDirection group values
for index in range(1, 6):
for group in [600, 200, 500, 300, 700, 800]:# the Conditions are organized into groups (https://openweathermap.org/weather-conditions), which I have prioritized
forecastItems = filter(lambda item: int(item.state.toString()) in range(group, group + 100), ir.getItem("gForecast_ConditionID_" + str(index)).getMembers())
if len(forecastItems) > 0:
sortedItems = sorted(forecastItems, key = lambda item: int(item.state.toString()))
selectedItem = sortedItems.pop()# this will provide the highest value in the sorted list of Items, which is usually the most severe condition
events.postUpdate("gForecast_ConditionID_" + str(index), selectedItem.state.toString())
events.postUpdate("gForecast_Condition_" + str(index), items[selectedItem.name.replace("ID", "")].toString())
events.postUpdate("gForecast_IconID_" + str(index), items[selectedItem.name.replace("Condition", "Icon")].toString())
events.postUpdate(ir.getItem("gForecast_Icon_" + str(index)), items[selectedItem.name.replace("ConditionID", "Icon")])
break
# this can be removed when ArithmeticGroupFunction.Avg() is fixed for Number:Angle
windDirectionItemStates = map(lambda item: item.state.intValue(), filter(lambda member: member.state != NULL and member.state != UNDEF, ir.getItem("gForecast_WindDirection_" + str(index)).getMembers()))
if len(windDirectionItemStates) > 0:
windDirectionAvg = reduce(lambda x, y: (((x + y) / 2) if y - x < 180 else (x + y + 360) / 2) % 360, windDirectionItemStates)
events.postUpdate("gForecast_WindDirection_" + str(index), str(windDirectionAvg))
addOWMItemsToGroups.log.debug("Updated groups and Items")
addOWMItemsToGroups(None)
log = logging.getLogger("{}.TEST.util".format(LOG_PREFIX))
func_called = False
def test():
global func_called
func_called = True
# Create a couple of Items to test with
from core.items import add_item
log.info("Creating test Items")
number = "Countdown_Timer_Test_Number"
string = "Countdown_Timer_Test_String"
add_item(number, item_type="Number")
add_item(string, item_type="String")
try:
# Test that func_called on even seconds.
log.info("--------------------------- seconds")
timer = CountdownTimer(log, "2s", test, number)
time.sleep(2.1)
assert func_called, "Test1: function wasn't called when timer expired"
# Test that func_called on fraction of seconds.
log.info("--------------------------- milliseconds")
func_called = False
timer = CountdownTimer(
log, (datetime.now() + timedelta(seconds=2, microseconds=100000)),
test, number)
from core.rules import rule
from core.triggers import when
import configuration
reload(configuration)
from configuration import mode_dict
from core.items import add_item
try:
from org.openhab.core.thing import ChannelUID
except:
from org.eclipse.smarthome.core.thing import ChannelUID
from org.joda.time import DateTime, Interval
if not itemRegistry.getItems("Mode"):
add_item("Mode", item_type="String", label="Mode [%s]", category="House")
def mode_trigger_generator(mode_dict):
def generated_triggers(function):
for mode in list(mode_dict.keys()):
if mode_dict[mode].get("second") is not None and mode_dict[
mode].get("minute") is not None and mode_dict[mode].get(
"hour") is not None:
when("Time cron {} {} {} * * ?".format(
mode_dict[mode]["second"], mode_dict[mode]["minute"],
mode_dict[mode]["hour"]))(function)
if mode_dict[mode].get("channel") is not None and mode_dict[
mode].get("event") is not None:
when("Channel {} triggered {}".format(
mode_dict[mode]["channel"],
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
from core.rules import rule
from core.triggers import when
from core.metadata import get_metadata, get_key_value, get_value, remove_metadata
from core.utils import postUpdate, post_update_if_different
TRIGGER_ITEM = "InitItems"
# Create the triggering Item if it doesn't already exist.
if TRIGGER_ITEM not in items:
from core.items import add_item
add_item(TRIGGER_ITEM, item_type="Switch")
@rule("Initialize Items",
description="Updates Items with an initialization value at System start",
tags=["init", "openhab-rules-tools"])
@when("System started")
@when("Item {} received command ON".format(TRIGGER_ITEM))
def item_init(event):
"""Rule that triggers at System started and populates Items with an initial
value. The initialization value is defined in metadata with three key/values.
- value: value to send update the Item to
- override: optional boolean value to override the state of the Item
even if it isn't NULL, defaults to "False".
- clear: optional boolean value to delete the metadata once the Item is
updated. Defaults to "False".
from core.actions import Ephemeris
from core.utils import send_command_if_different
from core.log import log_traceback, logging, LOG_PREFIX
from org.joda.time import DateTime
from community.time_utils import to_today
from community.timer_mgr import TimerMgr
from community.rules_utils import create_simple_rule, delete_rule, load_rule_with_metadata
# Name of the Item to trigger reloading of the time of day rule.
ETOD_RELOAD_ITEM = "Reload_ETOD"
# Create the time of day state Item if it doesn't exist.
ETOD_ITEM = "TimeOfDay"
if ETOD_ITEM not in items:
from core.items import add_item
add_item(ETOD_ITEM, item_type="String")
# Metadata name space.
NAMESPACE = "etod"
# Timers that run at time of day transitions.
timers = TimerMgr()
# Logger to use before
log = logging.getLogger("{}.Ephemeris Time of Day".format(LOG_PREFIX))
@log_traceback
def check_config(i, log):
"""Verifies that all the required elements are present for an etod metadata."""
import community.deferred
reload(community.deferred)
from community.deferred import defer, cancel_all, cancel
from core.log import log_traceback, logging, LOG_PREFIX
from org.joda.time import DateTime
import time
log = logging.getLogger("{}.TEST.deferred".format(LOG_PREFIX))
log.info("Starting deferred tests")
# Create an Item to test with
log.info("Creating test Item Deferred_Test")
from core.items import add_item
item = "Deferred_Test"
add_item(item, item_type="Switch")
try:
events.postUpdate(item, "OFF")
time.sleep(0.1)
assert items[item] == OFF, "Item didn't initialize to OFF"
# Schedule based on DT
t = DateTime.now().plusSeconds(1)
defer(item, "ON", t, log)
time.sleep(1.1)
assert items[item] == ON, "Item didn't go to ON after a second with specific time"
# Schedule based on duration
defer(item, "OFF", "1s", log)
time.sleep(1.1)
