def add_localapp(global_id):
db = databasehelper.get_database(DB_NAME)
col = databasehelper.get_collection(db, DB_COLLECTION_LOCALAPPS)
app_id = ObjectId()
io_name = str(app_id) + '.io'
log_name = str(app_id) + '.log'
localapp = {
"_id":
app_id,
"name":
"test app int-int",
"note":
"",
"module_name":
"testapp",
"readtype":
'int',
"writetype":
'int',
"node_module_id":
global_id,
"configs": [{
"name": 'iofile',
"value": io_name,
"type": 'str'
}, {
"name": 'logfile',
"value": log_name,
"type": 'str'
}]
}
databasehelper.insert(col, localapp)
return str(app_id)
def add(info: dict) -> None:
db = dbhelper.get_database(DB_NAME)
col = dbhelper.get_collection(db, DB_COLLECTION_DEVICES)
if "_id" in info:
info["_id"] = ObjectId(info["_id"])
result = dbhelper.insert(col, info)
return result
def update(device_id: str, info: dict) -> None:
if "_id" in info:
del info["_id"]
db = dbhelper.get_database(DB_NAME)
col = dbhelper.get_collection(db, DB_COLLECTION_DEVICES)
result = dbhelper.update(col, {"_id": ObjectId(device_id)}, info)
return result
def find_node_module_info(node_module_id: str) -> dict:
db = databasehelper.get_database(DB_NAME)
col = databasehelper.get_collection(db, DB_COLLECTION_NODE_MODULES)
nodeinfo = list(databasehelper.find(col,
{'_id': ObjectId(node_module_id)}))
print(nodeinfo)
return nodeinfo[0]
def delete(node_id: str) -> None:
db = databasehelper.get_database(DB_NAME)
col = databasehelper.get_collection(db, DB_COLLECTION_NODES)
result = databasehelper.delete(col, {'_id': ObjectId(node_id)})
__unload_node(node_id)
datastoremanager.remove_datastore(node_id)
return True
def add_globalapp():
db = databasehelper.get_database(DB_NAME)
col = databasehelper.get_collection(db, DB_COLLECTION_GLOBALAPPS)
app_id = ObjectId()
globalapp = {
"_id":
app_id,
"name":
'test app int-int',
"note":
'',
"module_name":
'testapp',
"readtype":
'int',
"writetype":
'int',
"required_configs": [{
"name": 'iofile',
"type": 'str'
}, {
"name": 'logfile',
"type": 'str'
}]
}
databasehelper.insert(col, globalapp)
return str(app_id)
def update_node_info(node_id: str, updated_node: dict) -> None:
# Add info
db = databasehelper.get_database(DB_NAME)
col = databasehelper.get_collection(db, DB_COLLECTION_NODES)
result = databasehelper.update(col, {'_id': ObjectId(node_id)},
updated_node)
__load_node(node_id)
def add(node_module_id: str, new_node: dict) -> None:
# Add info
db = databasehelper.get_database(DB_NAME)
col = databasehelper.get_collection(db, DB_COLLECTION_NODES)
node_module_info = find_node_module_info(node_module_id)
new_node['module_name'] = node_module_info['module_name']
new_node['node_module_id'] = node_module_id
if '_id' in new_node:
new_node["_id"] = ObjectId(new_node["_id"])
result = databasehelper.insert(col, new_node)
__load_node(str(new_node['_id']))
def find_datastore_values(node_id: str, limit: int) -> list:
colname = DB_COLLECTION_TEMP_DATASTORE + str(node_id)
db = databasehelper.get_database(DB_NAME)
col = databasehelper.get_collection(db, colname)
values = list(
databasehelper.find(col, {}, {
'sort': [('time', -1)],
'limit': limit,
'projection': {
'_id': False
}
}))
return values
def __store(self) -> None:
db = databasehelper.get_database(DB_NAME)
colname = DB_COLLECTION_TEMP_DATASTORE + str(self.__id)
if not databasehelper.isExistCollection(db, colname):
col = databasehelper.create_collection(db, colname)
else:
col = databasehelper.get_collection(db, colname)
while self.__isrunning:
try:
readVal = self.__node.read()
doc = {'time': time.time(), 'value': readVal}
databasehelper.insert(col, doc)
time.sleep(self.interval)
except:
logmanager.error(TAG, sys.exc_info())
def add_rule(event_node, action_node):
db = databasehelper.get_database(DB_NAME)
col = databasehelper.get_collection(db, DB_COLLECTION_RULES)
rule = {
"name": "rule",
"on": True,
"event": {
"nodeid": event_node,
"operator": "==",
"value": 1,
"type": "int"
},
"action": {
"nodeid": action_node,
"value": 1,
"type": "int"
}
}
databasehelper.insert(col, rule)
def find_device_info(device_id: str) -> dict:
db = dbhelper.get_database(DB_NAME)
col = dbhelper.get_collection(db, DB_COLLECTION_DEVICES)
listdevices = list(dbhelper.find(col, {'_id': ObjectId(device_id)}))
return listdevices[0]
def find_parent_node_info(node_id: str) -> dict:
db = databasehelper.get_database(DB_NAME)
col = databasehelper.get_collection(db, DB_COLLECTION_PARENT_NODES)
nodeinfo = list(databasehelper.find(col, {'_id': ObjectId(node_id)}))
return nodeinfo[0]
def list_node_modules() -> list:
db = databasehelper.get_database(DB_NAME)
col = databasehelper.get_collection(db, DB_COLLECTION_NODE_MODULES)
listnodes = list(databasehelper.find(col, {}))
return listnodes
def __connectnodes(self) -> None:
db = dbhelper.get_database(DB_NAME)
times = {}
while self.__isrunning:
connectionscol = dbhelper.get_collection(db, DB_COLLECTION_RULES)
connections = list(dbhelper.find(connectionscol, {}))
for connection in connections:
if connection['on'] == False:
continue
event = connection['event']
if 'type' not in event:
continue
eventnodecol = dbhelper.get_collection(
db, DB_COLLECTION_TEMP_DATASTORE + str(event['nodeid']))
eventnodeid = str(event['nodeid'])
eventnodevalues = {}
if str(connection['_id']) in times:
eventnodevalues = list(
dbhelper.find(
eventnodecol,
{'time': {
"$gt": times[str(connection['_id'])]
}}, dict(sort=[('time', pymongo.ASCENDING)])))
else:
times[str(connection['_id'])] = time.time()
continue
firstvalue = ''
secondvalue = ''
firsttime = 0.0
secondtime = 0.0
for eventnodevalue in eventnodevalues:
tempvalue = secondvalue
temptime = secondtime
secondvalue = str(eventnodevalue['value'])
secondtime = float(eventnodevalue['time'])
firstvalue = tempvalue
firsttime = temptime
if firstvalue == '' or firsttime == 0.0:
continue
eventoperator = str(event['operator'])
eventvalue = str(event['value'])
eventtype = str(event['type'])
#logmanager.log(TAG, "Event first time: " + eventnodeid + ' ' + str(eventnodevalue['time']))
times[str(connection['_id'])] = firsttime
firstrule = eventtype + "('" + firstvalue + "') " + eventoperator + " " + eventtype + "('" + eventvalue + "')"
secondrule = eventtype + "('" + secondvalue + "') " + eventoperator + " " + eventtype + "('" + eventvalue + "')"
# Rule check
if eval(secondrule) and not eval(firstrule):
logmanager.log(TAG, "Detected: " + str(connection))
action = connection['action']
if 'type' not in action:
break
node_id = action['nodeid']
nodemanager.write_node_value(
str(node_id),
eval(action['type'] + "('" + str(action['value']) +
"')"))
break
time.sleep(self.interval)
def delete(connector_id: str) -> None:
db = dbhelper.get_database(DB_NAME)
col = dbhelper.get_collection(db, DB_COLLECTION_RULES)
dbhelper.delete(col, {'_id': ObjectId(connector_id)})
def drop_rules():
db = databasehelper.get_database(DB_NAME)
col = databasehelper.get_collection(db, DB_COLLECTION_RULES)
databasehelper.drop(col)
def remove_datastore(node_id: str) -> None:
colname = DB_COLLECTION_TEMP_DATASTORE + str(node_id)
db = databasehelper.get_database(DB_NAME)
col = databasehelper.get_collection(db, colname)
databasehelper.drop(col)
def list_rules() -> list:
db = dbhelper.get_database(DB_NAME)
col = dbhelper.get_collection(db, DB_COLLECTION_RULES)
listrules = list(dbhelper.find(col, {}))
return listrules
def find_rule(connector_id: str) -> dict:
db = dbhelper.get_database(DB_NAME)
col = dbhelper.get_collection(db, DB_COLLECTION_RULES)
rule = dbhelper.find(col, {'_id': ObjectId(connector_id)})
return rule[0]
def delete(device_id: str) -> None:
db = dbhelper.get_database(DB_NAME)
col = dbhelper.get_collection(db, DB_COLLECTION_DEVICES)
result = dbhelper.delete(col, {"_id": ObjectId(device_id)})
return result
def drop_devices():
db = databasehelper.get_database(DB_NAME)
col = databasehelper.get_collection(db, DB_COLLECTION_DEVICES)
databasehelper.drop(col)
def drop_db():
db = databasehelper.get_database(DB_NAME)
db.client.drop_database(db)
def find_parent_node_module_info_list_w_name(parent_module_name: str) -> list:
db = databasehelper.get_database(DB_NAME)
col = databasehelper.get_collection(db, DB_COLLECTION_PARENT_NODE_MODULES)
nodeinfo = list(
databasehelper.find(col, {'module_name': parent_module_name}))
return nodeinfo
def add(new_rule: dict) -> None:
db = dbhelper.get_database(DB_NAME)
col = dbhelper.get_collection(db, DB_COLLECTION_RULES)
if "_id" in new_rule:
new_rule["_id"] = ObjectId(new_rule["_id"])
dbhelper.insert(col, new_rule)
def list_devices() -> list:
db = dbhelper.get_database(DB_NAME)
col = dbhelper.get_collection(db, DB_COLLECTION_DEVICES)
listdevices = list(dbhelper.find(col, {}))
return listdevices
def update(connector_id: str, updated_rule: dict) -> None:
db = dbhelper.get_database(DB_NAME)
col = dbhelper.get_collection(db, DB_COLLECTION_RULES)
dbhelper.update(col, {'_id': ObjectId(connector_id)}, updated_rule)
def drop_localapps():
db = databasehelper.get_database(DB_NAME)
col = databasehelper.get_collection(db, DB_COLLECTION_LOCALAPPS)
databasehelper.drop(col)
def add_device(localapps):
db = databasehelper.get_database(DB_NAME)
col = databasehelper.get_collection(db, DB_COLLECTION_DEVICES)
device = {"name": "test", "note": "", "apps": localapps}
databasehelper.insert(col, device)
