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)