def day_night():
if request.method == 'GET':
data, code = get_data(required=DAYNIGHT_GET,
restrictive=True,
hardmode=True)
if code == 400:
return data_formatting(400)
selector = data['select']
collection = {}
for selected in selector:
output = []
if selected == 'full':
for daynight in DayNightTime.select():
dn = model_to_dict(daynight)
dn['uuid'] = str(dn['uuid'])
output.append(dn)
if len(selector) > 1:
collection[selected] = output
if len(collection.keys()) != 0:
output = collection
return data_formatting(data=output)
else:
data, code = get_data(required=DAYNIGHT_POST, restrictive=True)
if code == 400:
return data_formatting(400)
for day_night in DayNightTime.select():
day_night.stop = data['stop']
day_night.start = data['start']
day_night.ledbar = data['ledbar']
day_night.display = data['display']
day_night.generalleds = data['generalleds']
day_night.notification = data['notification']
day_night.pump = data['pump']
day_night.save()
for slave in list(Plant.select().where(Plant.role != 'master')):
information = {'min': data['start'], 'max': data['stop']}
MeshDedicatedDispatch().slave_update(0, information, slave)
MeshDedicatedDispatch().update('day night time',
DayNightTime.select()[0].uuid)
return data_formatting()
def plant_responsible(p_uuid):
# GET: select: email, wizard, username, full, default (full)
responsible = Plant.get(uuid=p_uuid).person
if request.method == 'GET':
responsible = model_to_dict(responsible)
responsible['uuid'] = str(responsible['uuid'])
data, code = get_data(required=PLANT_RESPONSIBLE_GET, restrictive=True)
if code == 400:
return data_formatting(400)
selector = data['select']
collection = {}
for selected in selector:
if selected != 'full':
used = [selected, 'uuid']
else:
used = list(responsible.keys())
output = {}
for key in used:
if key not in ['id', 'preset']:
output[key] = responsible[key]
if len(selector) > 1:
collection[selected] = output
if len(collection.keys()) != 0:
output = collection
return data_formatting(data=output)
else:
data, code = get_data(required=PLANT_RESPONSIBLE_POST,
restrictive=True)
if code == 400:
return data_formatting(400)
if data['email'] != '' and data['name'] != '':
responsible = Person.get(Person.email**data['email'],
Person.name**data['name'])
elif data['uuid'] != '':
responsible = Person.get(uuid=data['uuid'])
plant = Plant.get(uuid=p_uuid)
plant.person = responsible
plant.save()
return data_formatting()
def sensor(s_uuid):
# GET: select: range, unit, full, default (full)
try:
sensor = Sensor.get(uuid=s_uuid)
except Exception:
sensor = Sensor.get(name=s_uuid)
data, code = get_data(required=SENSOR_GET, restrictive=True, hardmode=True)
if code == 400:
return data_formatting(400)
selector = data['select']
collection = {}
for selected in selector:
if selected == 'full':
output = model_to_dict(sensor)
del output['id']
output['uuid'] = str(output['uuid'])
elif selected == 'range':
output = {'max_value': sensor.max_value, 'min_value': sensor.min_value}
else:
output = {selected: model_to_dict(sensor)[selected]}
if len(selector) > 1:
collection[selected] = output
if len(collection.keys()) != 0:
output = collection
return data_formatting(data=output)
def message(m_uuid):
# GET: select: message, full, default (full)
if request.method == 'GET':
message = MessagePreset.get(uuid=m_uuid)
data, code = get_data(required=MESSAGE_GET, restrictive=True, hardmode=True)
if code == 400:
return data_formatting(400)
selector = data['select']
collection = {}
for selected in selector:
if selected == 'full':
output = model_to_dict(message)
del output['id']
del output['created_at']
output['uuid'] = str(output['uuid'])
else:
output = {'message': message.message}
if len(selector) > 1:
collection[selected] = output
if len(collection.keys()) != 0:
output = collection
return data_formatting(data=output)
else:
data, code = get_data(required=MESSAGE_POST, restrictive=True)
if code == 400:
return data_formatting(400)
preset = MessagePreset.get(uuid=m_uuid)
preset.message = data['message']
preset.name = data['heading']
preset.save()
if data['person']:
plant = Plant.get(uuid=data['plant'])
plant.person.preset = preset
plant.person.save()
MeshDedicatedDispatch().update('message', preset.uuid)
return data_formatting()
def sensors():
# GET: select: minimal, normal, detailed, extensive, default (normal)
# GET: dict: Boolean
selectable = ['minimal', 'normal', 'detailed', 'extensive']
data, code = get_data(required=SENSORS_GET, restrictive=True, hardmode=True)
if code == 400:
return data_formatting(400)
mode = data['dict']
selector = data['select']
sensors = Sensor.select().dicts()
collection = {}
for selected in selector:
output = []
if selected not in selectable:
return data_formatting(400)
for sensor in list(sensors):
used = []
if selected in selectable:
used.append('uuid')
if selected in selectable[1:]:
used.append('name')
if selected in selectable[2:]:
used.append('unit')
used.append('model')
if selected in selectable[3:]:
used.append('persistant_offset')
used.append('min_value')
used.append('max_value')
data = [] if not mode else {}
for use in used:
if isinstance(sensor[use], UUID):
sensor[use] = str(sensor[use])
if not mode:
data.append(sensor[use])
else:
data[use] = sensor[use]
output.append(data)
if len(selector) > 1:
collection[selected] = output
if len(collection.keys()) != 0:
output = collection
return data_formatting(data=output)
def plant_sensors(p_uuid):
# GET: select: range (default), default
plant = Plant.get(uuid=p_uuid)
data, code = get_data(required=PLANT_SENSORS_GET,
restrictive=True,
hardmode=True)
if code == 400:
return data_formatting(400)
selector = data['select']
collection = {}
for selected in selector:
if selected == 'range':
sensors = Sensor.select()
output = []
for sensor in sensors:
ranges = SensorSatisfactionValue.select() \
.where(SensorSatisfactionValue.plant == plant) \
.where(SensorSatisfactionValue.sensor == sensor)
tmp = {}
for spectrum in ranges:
tmp[spectrum.level.name_color] = {
'max': spectrum.max_value,
'min': spectrum.min_value
}
if spectrum.level.name_color == 'red':
tmp[spectrum.level.name_color] = {
'max': sensor.max_value,
'min': sensor.min_value
}
output.append({
'settings': tmp,
'sensor': sensor.name,
'uuid': str(sensor.uuid)
})
if len(selector) > 1:
collection[selected] = output
if len(collection.keys()) != 0:
output = collection
return data_formatting(data=output)
def host():
if request.method == 'GET':
plant = Plant.get(host=True)
data, code = get_data(required=HOST_GET,
restrictive=True,
hardmode=True)
if code == 400:
return data_formatting(400)
selector = data['select']
print('Host: {}'.format(str(selector)))
collection = {}
# output = {}
for selected in selector:
output = []
if selected == 'full':
output = model_to_dict(plant)
output['timestamp'] = output['created_at'].timestamp()
output['uuid'] = str(output['uuid'])
del output['id']
del output['person']
del output['created_at']
if len(selector) > 1:
collection[selected] = output
if len(collection.keys()) != 0:
output = collection
return data_formatting(data=output)
else:
local = Plant.get(localhost=True)
if not local.host:
host = Plant.get(host=True)
host.host = False
host.save()
local.host = True
local.save()
MeshDedicatedDispatch().update('host', local.uuid)
return data_formatting()
def plant_message(p_uuid):
# GET: select: full
plant = Plant.get(uuid=p_uuid)
data, code = get_data(required=PLANT_MESSAGE_GET, restrictive=True)
if code == 400:
return data_formatting(400)
selector = data['select']
collection = {}
for selected in selector:
if selected == 'full':
message = plant.person.preset
output = {'uuid': str(message.uuid), 'message': message.message}
if len(selector) > 1:
collection[selected] = output
if len(collection.keys()) != 0:
output = collection
return data_formatting(data=output)
def discover():
# GET: select:
# GET: dict: Boolean
if request.method == 'GET':
data, code = get_data(required=DISCOVER_GET,
restrictive=True,
hardmode=True)
if code == 400:
return data_formatting(400)
mode = data['dict']
selector = data['select']
registered = data['registered']
selectable = ['minimal', 'normal', 'detailed', 'extensive']
collection = {}
if registered is not None:
meshobjects = MeshObject.filter(registered=registered).dicts()
else:
meshobjects = MeshObject.select().dicts()
for selected in selector:
output = []
for meshobject in list(meshobjects):
used = []
if selected in selectable:
used.append('ip')
if selected in selectable[1:]:
used.append('master')
if selected in selectable[2:]:
used.append('registered')
if selected in selectable[3:]:
used.append('created_at')
data = [] if not mode else {}
for use in used:
if isinstance(meshobject[use], UUID):
meshobject[use] = str(meshobject[use])
if isinstance(meshobject[use], datetime.datetime):
meshobject[use] = meshobject[use].timestamp()
if not mode:
data.append(meshobject[use])
else:
data[use] = meshobject[use]
output.append(data)
if len(selector) > 1:
collection[selected] = output
if len(collection.keys()) != 0:
output = collection
return data_formatting(data=output)
else:
data, code = get_data(required=DISCOVER_POST, restrictive=True)
if code == 400:
return data_formatting(400)
if data['execute']:
MeshNetwork().discover(1)
return data_formatting()
def messages():
if request.method == 'GET':
# GET: select: minimal, normal, detailed, extensive, default (normal)
# GET: dict: Boolean
data, code = get_data(required=MESSAGES_GET, restrictive=True, hardmode=True)
if code == 400:
return data_formatting(400)
mode = data['dict']
selector = data['select']
selectable = ['minimal', 'normal', 'detailed', 'extensive']
messages = MessagePreset.select().dicts()
collection = {}
for selected in selector:
output = []
for message in list(messages):
used = []
if selected in selectable:
used.append('uuid')
if selected in selectable[1:]:
used.append('name')
if selected in selectable[2:]:
used.append('created_at')
if selected in selectable[3:]:
used.append('message')
data = [] if not mode else {}
for use in used:
if isinstance(message[use], UUID):
message[use] = str(message[use])
if not mode:
data.append(message[use])
else:
data[use] = message[use]
output.append(data)
if len(selector) > 1:
collection[selected] = output
if len(collection.keys()) != 0:
output = collection
return data_formatting(data=output)
else:
data, code = get_data(required=MESSAGES_PUT, restrictive=True)
if code == 400:
return data_formatting(400)
for message in MessagePreset.select():
if message.name == data['heading']:
return data_formatting(304)
msg = MessagePreset()
msg.name = data['heading']
msg.message = data['message']
msg.save()
if data['person']:
plant = Plant.get(uuid=data['plant'])
plant.person.preset = msg
plant.person.save()
MeshDedicatedDispatch().update('message', msg.uuid)
return data_formatting()
def person(r_uuid):
# GET: select: full, default (full)
# POST: replaceable: email, name, wizard
# DELETE
person = Person.get(uuid=r_uuid)
if request.method == 'GET':
data, code = get_data(required=PERSON_GET,
restrictive=True,
hardmode=True)
if code == 400:
return data_formatting(400)
selector = data['select']
collection = {}
for selected in selector:
if selected == 'full':
output = model_to_dict(person)
del output['id']
del output['preset']
output['uuid'] = str(output['uuid'])
if len(selector) > 1:
collection[selected] = output
if len(collection.keys()) != 0:
output = collection
return data_formatting(data=output)
elif request.method == 'POST':
data, code = get_data(required=PERSON_POST, restrictive=True)
if code == 400:
return data_formatting(400)
if data['name'] != '':
person.name = data['name']
if data['email'] != '':
person.email = data['email']
if data['wizard'] is not None:
if data['wizard']:
wizards = Person.filter(wizard=True)
for old in wizards:
old.wizard = False
old.save()
person.wizard = data['wizard']
person.save()
MeshDedicatedDispatch().update('person', person.uuid)
return data_formatting()
else:
if Person.select().where(Person.uuid == r_uuid).count() > 0:
Person.get(uuid=r_uuid).delete_instance()
else:
return data_formatting(304)
return data_formatting()
def persons():
# GET: select: minimal, normal, detailed, extensive, default (normal)
# GET: dict: Boolean
if request.method == 'GET':
data, code = get_data(required=PERSONS_GET,
restrictive=True,
hardmode=True)
if code == 400:
return data_formatting(400)
mode = data['dict']
selector = data['select']
persons = Person.select().dicts()
selectable = ['minimal', 'normal', 'detailed', 'extensive']
collection = {}
for selected in selector:
output = []
for person in list(persons):
used = []
if selected in selectable:
used.append('uuid')
if selected in selectable[1:]:
used.append('name')
if selected in selectable[2:]:
used.append('email')
if selected in selectable[3:]:
used.append('wizard')
data = [] if not mode else {}
for use in used:
if isinstance(person[use], UUID):
person[use] = str(person[use])
if not mode:
data.append(person[use])
else:
data[use] = person[use]
output.append(data)
if len(selector) > 1:
collection[selected] = output
if len(collection.keys()) != 0:
output = collection
return data_formatting(data=output)
else:
data, code = get_data(required=PERSONS_PUT,
restrictive=True,
hardmode=True)
if code == 400:
return data_formatting(400)
person = Person()
person.name = data['name']
person.email = data['email']
person.wizard = data['wizard']
if data['wizard']:
wizards = Person.filter(wizard=True)
for old in wizards:
old.wizard = False
old.save()
person.save()
return data_formatting()
def plant_status(p_uuid):
# GET: select: average, online
plant = Plant.get(uuid=p_uuid)
data, code = get_data(required=PLANT_STATUS_GET, restrictive=True)
if code == 400:
return data_formatting(400)
selector = data['select']
collection = {}
for selected in selector:
if selected == 'average':
c = Sensor.select().count()
sensor_count = SensorCount.select() \
.where(SensorCount.plant == plant)
average = {'red': 0, 'yellow': 0, 'green': 0}
for count in sensor_count:
average[count.level.name_color] += count.count
summary = 0
for key, item in average.items():
average[key] /= c
summary += average[key]
output = {}
for key, item in average.items():
try:
output[key] = [round(item / summary * 100), item]
except ZeroDivisionError:
output[key] = [0, item]
else:
uptimes = PlantNetworkUptime.select() \
.where(PlantNetworkUptime.plant == plant)
output = {}
summary = 0
for uptime in uptimes:
output[uptime.status.name] = [
0, uptime.overall, uptime.current
]
summary += uptime.overall
for key, uptime in output.items():
print(type(output[key][1]))
output[key][0] = round(output[key][1] / summary *
100) if output[key][1] != 0 else 0
if output == {}:
output = {'online': [0, 0.0, 0.0], 'offline': [0, 0.0, 0.0]}
if plant.localhost:
output = {'online': [100, 1, 1], 'offline': [100, 1, 1]}
if len(selector) > 1:
collection[selected] = output
if len(collection.keys()) != 0:
output = collection
return data_formatting(data=output)
def plant_sensor(p_uuid, s_uuid):
# GET: select: latest, prediction, data, current, range, extreme, message
# GET: max: Boolean (extreme)
# GET: ever: Boolean (extreme)
# GET: backlog: Boolean (extreme)
# GET: start: Integer (data)
# GET: stop: Integer (data)
# GET: count: Boolean (data)
plant = Plant.get(uuid=p_uuid)
try:
sensor = Sensor.get(uuid=s_uuid)
except Exception:
sensor = Sensor.get(name=s_uuid)
if plant.role != 'master' and sensor.name not in slave_supported:
plant = Plant.get(uuid=plant.role)
data, code = get_data(required=PLANT_SENSOR_GET, restrictive=True)
if code == 400:
return data_formatting(400)
selector = data['select']
maximum = data['max']
backlog = data['backlog']
start = data['start']
stop = data['stop']
ever = data['ever']
collection = {}
for selected in selector:
if selected == 'timespan':
start = datetime.datetime.min if start <= 0 else datetime.datetime.fromtimestamp(
start)
stop = datetime.datetime.max if stop >= 253402297200 else datetime.datetime.fromtimestamp(
stop)
if selected in [
'latest', 'current', 'extreme', 'data', 'count', 'timespan'
]:
data = SensorData.select(SensorData.value,
SensorData.persistant,
fn.CAST(Clause(fn.strftime('%s', SensorData.created_at), SQL('AS INT'))).alias('timestamp')) \
.where(SensorData.plant == plant) \
.where(SensorData.sensor == sensor) \
.order_by(SensorData.created_at.asc()) \
.dicts()
elif selected in ['prediction']:
data = SensorDataPrediction.select(SensorDataPrediction.value,
fn.CAST(Clause(fn.strftime('%s', SensorDataPrediction.time), SQL('AS INT'))).alias('timestamp')) \
.where(SensorDataPrediction.plant == plant) \
.where(SensorDataPrediction.sensor == sensor) \
.order_by(SensorDataPrediction.created_at.asc()) \
.dicts()
elif selected in ['range']:
data = SensorSatisfactionValue.select() \
.where(SensorSatisfactionValue.plant == plant) \
.where(SensorSatisfactionValue.sensor == sensor)
if selected in ['latest', 'current']:
data = data.order_by(SensorData.created_at.desc()).limit(1)
output = list(data)[0]
elif selected == 'prediction':
output = list(data)
elif selected == 'range':
output = {}
for spectrum in data:
output[spectrum.level.name_color] = {
'max': spectrum.max_value,
'min': spectrum.min_value
}
if spectrum.level.name_color == 'red':
output[spectrum.level.name_color] = {
'max': sensor.max_value,
'min': sensor.min_value
}
elif selected == 'extreme':
target = datetime.datetime.combine(datetime.date.today(),
datetime.datetime.min.time())
if backlog and not ever:
output = None
while output is None:
output = get_sensor_data_high_low(plant, sensor, maximum,
target)
target = target - datetime.timedelta(days=1)
else:
if ever:
target = None
output = get_sensor_data_high_low(plant, sensor, maximum,
target)
elif selected == 'count':
output = data.count()
elif selected == 'timespan':
data = data.where(SensorData.created_at > start,
SensorData.created_at < stop)
output = list(data)
else:
data = data.order_by(
SensorData.created_at.desc()).offset(start).limit(stop - start)
output = list(data)
if len(selector) > 1:
collection[selected] = output
if len(collection.keys()) != 0:
output = collection
return data_formatting(data=output)
def plant(p_uuid):
if request.method == 'GET':
# GET: select: intervals, created_at, type/species, survived, location, full, default (full)
data, code = get_data(required=PLANT_GET,
restrictive=True,
hardmode=True)
if code == 400:
return data_formatting(400)
collection = {}
selector = data['select']
for selected in selector:
plant = list(
Plant.select(
Plant,
fn.CAST(
Clause(fn.strftime('%s', Plant.created_at),
SQL('AS INT'))).alias('created_at')).where(
Plant.uuid == p_uuid).dicts())[0]
plant['uuid'] = str(plant['uuid'])
if selected not in ['full', 'intervals', 'survived']:
output = {selected: plant[selected]}
elif selected in ['intervals']:
output = {
'connection_lost': plant['connection_lost'],
'non_persistant':
int(plant['persistant_hold'] * 5 / 60 / 24),
'notification': plant['interval']
}
elif selected in ['survived']:
difference = datetime.datetime.now(
) - datetime.datetime.fromtimestamp(plant['created_at'])
output = float(difference.days +
round((difference.seconds // 3600) / 24, 1))
else:
output = plant
if len(selector) > 1:
collection[selected] = output
if len(collection.keys()) != 0:
output = collection
return data_formatting(data=output)
elif request.method == 'POST':
# POST: replace: name, type, location, ranges, responsible
# POST: mode: add, reset, online, offline
# POST: new: DATA
data, code = get_data(required=PLANT_POST, restrictive=True)
if code == 400:
return data_formatting(400)
keys = list(data.keys())
if data['mode'] == '':
mode = 'add' if 'satisfaction' in keys else 'offline'
else:
mode = data['mode'].lower()
plant = Plant.get(uuid=p_uuid)
if data['name'] != '':
plant.name = data['name']
if data['species'] != '':
plant.species = data['species']
if data['location'] != '':
plant.location = data['location']
if data['ranges']:
try:
sensor = Sensor.get(name=data['sensor'])
except Exception:
try:
sensor = Sensor.get(uuid=data['sensor'])
except Exception:
return data_formatting(400)
level_yellow = SensorSatisfactionLevel.get(
SensorSatisfactionLevel.name_color == 'yellow')
level_green = SensorSatisfactionLevel.get(
SensorSatisfactionLevel.name_color == 'green')
value_yellow = SensorSatisfactionValue.get(
SensorSatisfactionValue.plant == plant,
SensorSatisfactionValue.sensor == sensor,
SensorSatisfactionValue.level == level_yellow)
value_green = SensorSatisfactionValue.get(
SensorSatisfactionValue.plant == plant,
SensorSatisfactionValue.sensor == sensor,
SensorSatisfactionValue.level == level_green)
value_yellow.min_value = int(request.form.getlist('range[]')[0])
value_green.min_value = int(request.form.getlist('range[]')[1])
value_green.max_value = int(request.form.getlist('range[]')[2])
value_yellow.max_value = int(request.form.getlist('range[]')[3])
value_green.save()
value_yellow.save()
MeshDedicatedDispatch().update('plant satisfaction level',
plant.uuid)
if sensor.name == 'moisture' and plant.role != 'master':
# logger.info('executing slave update')
information = {
'min': value_yellow.min_value,
'max': value_yellow.max_value
}
MeshDedicatedDispatch().slave_update(2, information, plant)
if data['responsible']:
person = Person.get(email=data['email'], name=data['firstname'])
plant.person = person
plant.save()
if data['satisfaction']:
if mode == 'add':
plant.sat_streak += 1
else:
plant.sat_streak = 1
if data['alive']:
counterpart = 'online' if mode == 'offline' else 'offline'
status = PlantNetworkStatus.get(name=mode)
counterpart = PlantNetworkStatus.get(name=counterpart)
if plant.role == 'master':
return data_formatting()
status = PlantNetworkUptime.get(plant=plant, status=status)
counterpart = PlantNetworkUptime.get(plant=plant,
status=counterpart)
if counterpart.current != 0:
counterpart.current = 0
counterpart.save()
status.current += 1
status.overall += 1
status.save()
if data['notification']:
_, _, hours = time_request_from_converter(data)
plant.interval = int(round(hours))
if data['connection-lost']:
_, minutes, _ = time_request_from_converter(data)
plant.connection_lost = int(round(minutes))
if data['non-persistant']:
_, minutes, _ = time_request_from_converter(data)
plant.persistant_hold = int(round(minutes / 5))
plant.save()
MeshDedicatedDispatch().update('plant', plant.uuid)
return data_formatting()
def plants():
# GET: select: minimal, normal, detailed, extensive, master, satisfaction, default (normal)
# GET: dict: Boolean
if request.method == 'GET':
data, code = get_data(required=PLANTS_GET,
restrictive=True,
hardmode=True)
if code == 400:
return data_formatting(400)
selector = data['select']
mode = data['dict']
root_plants = Plant.select().dicts()
collection = {}
for selected in selector:
plants = root_plants.where(
Plant.role ==
'master') if selected == 'master' else root_plants
plants = list(plants)
output = []
if selected not in ['satisfaction', 'sensorsatisfaction']:
for plant in plants:
used = []
if selected in [
'minimal', 'normal', 'detailed', 'extensive',
'master'
]:
used.append('uuid')
if selected in [
'normal', 'detailed', 'extensive', 'master'
]:
used.append('name')
if selected in ['detailed', 'extensive', 'master']:
used.append('role')
used.append('localhost')
if selected in ['extensive', 'master']:
used.append('active')
data = [] if not mode else {}
for use in used:
if isinstance(plant[use], UUID):
plant[use] = str(plant[use])
if not mode:
data.append(plant[use])
else:
data[use] = plant[use]
output.append(data)
elif selected in ['satisfaction', 'sensorsatisfaction']:
output = {}
sensors = Sensor.select()
for plant in plants:
host = None
if plant['role'] != 'master':
host = Plant.get(Plant.uuid == plant['role'])
if selected == 'satisfaction':
statuses = []
else:
output[str(plant['uuid'])] = {}
for sensor in sensors:
target = Plant.get(uuid=plant['uuid'])
if sensor.name not in slave_supported and host is not None:
target = host
status = SensorStatus.get(
SensorStatus.sensor == sensor,
SensorStatus.plant == target)
if selected == 'satisfaction':
inserted = 1
if status.level.label == 'threat':
inserted = 3
elif status.level.label == 'cautioning':
inserted = 2
statuses.append(inserted)
else:
if status.level.label not in output[str(
plant['uuid'])]:
output[str(
plant['uuid'])][status.level.label] = []
output[str(
plant['uuid'])][status.level.label].append({
'name':
sensor.name,
'uuid':
str(sensor.uuid)
})
if selected == 'satisfaction':
maximum = max(statuses)
label = 'optimum'
if maximum == 3:
label = 'threat'
elif maximum == 2:
label = 'cautioning'
output[str(plant['uuid'])] = {
'streak': plant['sat_streak'],
'name': label
}
if len(selector) > 1:
collection[selected] = output
if len(collection.keys()) != 0:
output = collection
return data_formatting(data=output)
else:
# PUT: register: true
data, code = get_data(required=PLANTS_PUT, restrictive=True)
if code == 400:
return data_formatting(400)
register = data['register']
plants = list(Plant.select(Plant.ip == data['ip']).dicts())
discovered = MeshObject.get(ip=data['ip'])
if plants.count() == 0:
return data_formatting(304)
plant = Plant()
plant.name = data['name']
plant.location = data['location']
plant.species = data['species']
plant.interval = data['interval']
plant.person = Person.get(email=data['email'])
plant.ip = data['ip']
plant.sat_streak = 0
if data['uuid'] != '':
plant.uuid = data['uuid']
if data['persistant_hold'] != '':
plant.persistant_hold = data['persistant_hold']
if not discovered.master:
if data['role'] == '':
master = Plant.get(localhost=True)
else:
master = Plant.get(uuid=data['role'])
plant.role = str(master.uuid)
plant.save()
local_plant = Plant.get(localhost=True)
for model in [
SensorStatus, SensorCount, SensorSatisfactionValue,
PlantNetworkUptime
]:
copy_model_instance_from_localhost(plant, model,
model.plant == local_plant)
for count in list(
SensorCount.select().where(SensorCount.plant == plant)):
count.count = 0
count.save()
for uptime in list(PlantNetworkUptime.select().where(
PlantNetworkUptime.plant == plant)):
uptime.overall = 0
uptime.current = 0
uptime.save()
if register:
MeshDedicatedDispatch().register(plant)
return data_formatting()
