def GET(self):
qdict = web.input()
errorCode = qdict.get('errorCode', 'none')
if 'delete' in qdict:
delete = qdict['delete']
if len(plugin_options['sounds']) > 0:
del_file = os.path.join(plugin_data_dir(),
plugin_options['sounds'][int(delete)])
if os.path.isfile(del_file):
os.remove(del_file)
errorCode = qdict.get('errorCode', 'DelOK')
read_folder()
log.debug(
NAME,
datetime_string() + ': ' +
_(u'Deleting file has sucesfully.'))
else:
errorCode = qdict.get('errorCode', 'DelNex')
log.error(
NAME,
datetime_string() + ': ' +
_(u'File for deleting not found!'))
return self.plugin_render.voice_station_sounds(plugin_options,
errorCode)
def GET(self):
global must_stop
qdict = web.input()
if checker is not None:
stop = helpers.get_input(qdict, 'stop', False, lambda x: True)
clear = helpers.get_input(qdict, 'clear', False, lambda x: True)
if 'test' in qdict:
command = -1
data = {}
if 'state' in qdict and int(qdict['state']) == 1:
command = plugin_options['on'][int(qdict['test'])]
if 'state' in qdict and int(qdict['state']) == 0:
command = plugin_options['off'][int(qdict['test'])]
if len(plugin_options['sounds']) > 0 and command != -1:
data['song'] = plugin_options['sounds'][command]
path = os.path.join(plugin_data_dir(), data['song'])
if os.path.isfile(path):
log.info(
NAME,
datetime_string() + u': ' +
_(u'Button test, song {}.').format(data['song']))
update_song_queue(data) # save song name to song queue
else:
log.info(
NAME,
datetime_string() + u': ' + _(u'File not exists!'))
else:
log.info(
NAME,
datetime_string() + u': ' + _(u'File not exists!'))
if stop:
must_stop = True
log.info(NAME, datetime_string() + u': ' + _(u'Button Stop.'))
if clear:
must_stop = True
song_queue = read_song_queue()
while len(song_queue) > 0:
song_queue = read_song_queue()
del song_queue[0]
write_song_queue(song_queue)
log.clear(NAME)
log.info(
NAME,
datetime_string() + u': ' + _(u'Button clear playlist.'))
try:
return self.plugin_render.voice_station(plugin_options,
log.events(NAME))
except Exception:
log.error(
NAME,
_(u'Voice Station plug-in') + ':\n' + traceback.format_exc())
set_to_default()
return self.plugin_render.voice_station(plugin_options,
log.events(NAME))
def GET(self):
global wind_sender
qdict = web.input()
reset = helpers.get_input(qdict, 'reset', False, lambda x: True)
delete = helpers.get_input(qdict, 'delete', False, lambda x: True)
show = helpers.get_input(qdict, 'show', False, lambda x: True)
if wind_sender is not None and reset:
wind_sender.status['max_meter'] = 0
wind_sender.status['log_date_maxspeed'] = datetime_string()
log.clear(NAME)
log.info(
NAME,
datetime_string() + ' ' + _(u'Maximal speed has reseted.'))
raise web.seeother(plugin_url(settings_page), True)
if wind_sender is not None and delete:
write_log([])
create_default_graph()
log.info(NAME,
datetime_string() + ' ' + _(u'Deleted all log files OK'))
raise web.seeother(plugin_url(settings_page), True)
if wind_sender is not None and 'history' in qdict:
history = qdict['history']
wind_options.__setitem__('history', int(history))
if wind_sender is not None and show:
raise web.seeother(plugin_url(log_page), True)
return self.plugin_render.wind_monitor(wind_options,
wind_sender.status,
log.events(NAME))
def POST(self):
global saved_emails
email_options.web_update(web.input())
qdict = web.input()
test = get_input(qdict, 'test', False, lambda x: True)
delete = get_input(qdict, 'del', False, lambda x: True)
if email_sender is not None:
email_sender.update()
if test:
regex = re.compile(r'([A-Za-z0-9]+[.-_])*[A-Za-z0-9]+@[A-Za-z0-9-]+(\.[A-Z|a-z]{2,})+') # SMTP username
if not re.fullmatch(regex, email_options['emlusr']):
log.clear(NAME)
log.info(NAME,datetime_string() + ': ' + _(u'Sender e-mail address appears to be invalid!'))
raise web.seeother(plugin_url(settings_page), True)
body = datetime_string() + ': ' + _(u'This is test e-mail from OSPy. You can ignore it.')
logtext = _(u'This is test e-mail from OSPy. You can ignore it.')
try_mail(body, logtext)
if delete:
log.info(NAME, datetime_string() + ': ' + _(u'Email Queue was deleted.'))
write_email([])
saved_emails = 0
raise web.seeother(plugin_url(settings_page), True)
def notify_station_off(name, **kw):
if plugin_options['enabled']:
current_time = datetime.datetime.now()
try:
if int(current_time.hour) >= int(
plugin_options['start_hour']) and int(
current_time.hour) <= int(plugin_options['stop_hour']):
st_nr = int(kw[u"txt"])
log.clear(NAME)
log.info(
NAME,
datetime_string() + u': ' +
_(u'Stations {} OFF').format(str(st_nr + 1)))
data = {}
if len(plugin_options['sounds']) > 0:
data['song'] = plugin_options['sounds'][int(
plugin_options['off'][st_nr])]
path = os.path.join(plugin_data_dir(), data['song'])
if os.path.isfile(path):
update_song_queue(data) # save song name to song queue
else:
log.info(
NAME,
datetime_string() + u': ' + _(u'File not exists!'))
except Exception:
log.error(
NAME,
_(u'Voice Station plug-in') + ':\n' + traceback.format_exc())
def get_client():
if is_python2():
if not os.path.exists("/usr/lib/python2.7/dist-packages/pip"):
log.clear(NAME)
log.info(NAME, _('PIP is not installed.'))
log.info(NAME, _('Please wait installing python-pip...'))
log.info(NAME, _('This operation takes longer (minutes)...'))
cmd = "sudo apt-get install python-pip -y"
proc_install(cmd)
else:
if not os.path.exists("/usr/lib/python3/dist-packages/pip"):
log.clear(NAME)
log.info(NAME, _('PIP3 is not installed.'))
log.info(NAME, _('Please wait installing python3-pip...'))
log.info(NAME, _('This operation takes longer (minutes)...'))
cmd = "sudo apt-get install python3-pip -y"
proc_install(cmd)
try:
import paho.mqtt.client as mqtt
except ImportError:
log.error(NAME, _('MQTT Plugin requires paho mqtt.'))
log.info(NAME, _('Paho-mqtt is not installed.'))
log.info(NAME, _('Please wait installing paho-mqtt...'))
log.info(NAME, _('This operation takes longer (minutes)...'))
if is_python2():
cmd = "sudo pip install paho-mqtt"
else:
cmd = "sudo pip3 install paho-mqtt"
proc_install(cmd)
try:
import paho.mqtt.client as mqtt
except ImportError:
mqtt = None
log.error(NAME, _('Error try install paho-mqtt manually.'))
time.sleep(60)
if mqtt is not None and plugin_options["use_mqtt"]:
try:
_client = mqtt.Client(options.name) # Use system name as client ID
_client.on_connect = on_connect # flag = 1 is connected
_client.on_disconnect = on_disconnect # flag = 0 is disconnected
_client.on_message = on_message # Attach function to callback
log.clear(NAME)
log.info(NAME, datetime_string() + ' ' + _('Connecting to broker') + '...')
_client.username_pw_set(plugin_options['user_name'], plugin_options['user_password'])
_client.connect(plugin_options['broker_host'], plugin_options['broker_port'], 60)
_client.loop_start()
log.info(NAME, datetime_string() + ' ' + _('OK'))
return _client
except Exception:
log.error(NAME, _('MQTT plugin couldnot initalize client') + ':\n' + traceback.format_exc())
pass
return None
def run(self):
last_rain = False
finished_count = len(
[run for run in log.finished_runs() if not run['blocked']])
if email_options[
"emlpwron"]: # if eml_power_on send email is enable (on)
body = (datetime_string() + ': System was powered on.')
if email_options["emllog"]:
self.try_mail(body, EVENT_FILE)
else:
self.try_mail(body)
while not self._stop_event.is_set():
try:
# Send E-amil if rain is detected
if email_options["emlrain"]:
if inputs.rain_sensed() and not last_rain:
body = (datetime_string() + ': System detected rain.')
self.try_mail(body)
last_rain = inputs.rain_sensed()
# Send E-mail if a new finished run is found
if email_options["emlrun"]:
finished = [
run for run in log.finished_runs()
if not run['blocked']
]
if len(finished) > finished_count:
body = datetime_string() + ':\n'
for run in finished[finished_count:]:
duration = (run['end'] -
run['start']).total_seconds()
minutes, seconds = divmod(duration, 60)
body += "Finished run:\n"
body += " Program: %s\n" % run['program_name']
body += " Station: %s\n" % stations.get(
run['station']).name
body += " Start time: %s \n" % datetime_string(
run['start'])
body += " Duration: %02d:%02d\n\n" % (minutes,
seconds)
self.try_mail(body)
finished_count = len(finished)
self._sleep(5)
except Exception:
log.error(NAME, 'E-mail plug-in:\n' + traceback.format_exc())
self._sleep(60)
def GET(self):
global sender, status
qdict = web.input()
reset = helpers.get_input(qdict, 'reset', False, lambda x: True)
if sender is not None and reset:
plugin_options.__setitem__('sum_one', 0)
plugin_options.__setitem__('sum_two', 0)
plugin_options.__setitem__('last_reset', datetime_string())
log.clear(NAME)
log.info(NAME, datetime_string() + ': ' + _(u'Counter has reseted'))
raise web.seeother(plugin_url(settings_page), True)
return self.plugin_render.water_consumption_counter(plugin_options, log.events(NAME))
def on_stop():
client = get_client()
if client is not None:
client.disconnect()
client.loop_stop()
client = None
log.info(NAME, datetime_string() + ' ' + _('Client stop'))
def update_log():
"""Update data in json files."""
global status
### Data for log ###
try:
log_data = read_log()
except:
write_log([])
log_data = read_log()
from datetime import datetime
data = {'datetime': datetime_string()}
data['date'] = str(datetime.now().strftime('%d.%m.%Y'))
data['time'] = str(datetime.now().strftime('%H:%M:%S'))
data['minimum'] = str(status['minlevel'])
data['maximum'] = str(status['maxlevel'])
data['actual'] = str(get_all_values()[0])
data['volume'] = str(get_all_values()[3])
log_data.insert(0, data)
if tank_options['log_records'] > 0:
log_data = log_data[:tank_options['log_records']]
try:
write_log(log_data)
except:
write_log([])
### Data for graph log ###
try:
graph_data = read_graph_log()
except:
create_default_graph()
graph_data = read_graph_log()
timestamp = int(time.time())
try:
minimum = graph_data[0]['balances']
minval = {'total': status['minlevel']}
minimum.update({timestamp: minval})
maximum = graph_data[1]['balances']
maxval = {'total': status['maxlevel']}
maximum.update({timestamp: maxval})
actual = graph_data[2]['balances']
actval = {'total': get_all_values()[0]}
actual.update({timestamp: actval})
volume = graph_data[3]['balances']
volumeval = {'total': get_all_values()[3]}
volume.update({timestamp: volumeval})
write_graph_log(graph_data)
log.info(NAME, _(u'Saving to log files OK'))
except:
create_default_graph()
def update_debug_log(byte_0=0, byte_1=0, val=0, byte_2=0, byte_3=0):
"""Update data in debug json files."""
### Data for log ###
try:
log_data = read_debug_log()
except:
write_log([])
log_data = read_debug_log()
from datetime import datetime
data = {'datetime': datetime_string()}
data['date'] = str(datetime.now().strftime('%d.%m.%Y'))
data['b0'] = str(byte_0)
data['b1'] = str(byte_1)
data['b2'] = str(byte_2)
data['b3'] = str(byte_3)
data['val'] = str(val)
log_data.insert(0, data)
try:
write_debug_log(log_data)
except:
write_debug_log([])
def read_buttons():
try:
import smbus
bus = smbus.SMBus(0 if helpers.get_rpi_revision() == 1 else 1)
# Set 8 GPA pins as input pull-UP
try_io(lambda: bus.write_byte_data(plugin_options[
'i2c_addr'], 0x0C, 0xFF)) #bus.write_byte_data(0x27,0x0C,0xFF)
# Wait for device
time.sleep(0.2)
# Read state of GPIOA register
MySwitch = try_io(
lambda: bus.read_byte_data(plugin_options[
'i2c_addr'], 0x12)) # MySwitch = bus.read_byte_data(0x27,0x12)
inBut = 255 - MySwitch
# inversion number for led off if button is not pressed
led_outputs(inBut) # switch on actual led if button is pressed
button_number = -1
if inBut == 128:
button_number = 7
log.debug(NAME, _(u'Switch 8 pressed'))
if inBut == 64:
button_number = 6
log.debug(NAME, _(u'Switch 7 pressed'))
if inBut == 32:
button_number = 5
log.debug(NAME, _(u'Switch 6 pressed'))
if inBut == 16:
button_number = 4
log.debug(NAME, _(u'Switch 5 pressed'))
if inBut == 8:
button_number = 3
log.debug(NAME, _(u'Switch 4 pressed'))
if inBut == 4:
button_number = 2
log.debug(NAME, _(u'Switch 3 pressed'))
if inBut == 2:
button_number = 1
log.debug(NAME, _(u'Switch 2 pressed'))
if inBut == 1:
button_number = 0
log.debug(NAME, _(u'Switch 1 pressed'))
return button_number #if button is not pressed return -1
except Exception:
log.clear(NAME)
log.error(NAME, datetime_string() + ': ' + _(u'Read button - FAULT'))
log.error(
NAME,
_(u'Is hardware connected? Is bus address corectly setuped?'))
#log.error(NAME, '\n' + traceback.format_exc())
pass
return -1
def update_log():
"""Update data in json files."""
### Data for log ###
try:
log_data = read_log()
except:
write_log([])
log_data = read_log()
from datetime import datetime
data = {'datetime': datetime_string()}
data['date'] = str(datetime.now().strftime('%d.%m.%Y'))
data['time'] = str(datetime.now().strftime('%H:%M:%S'))
data['maximum'] = str(get_all_values()[1])
data['actual'] = str(get_all_values()[0])
log_data.insert(0, data)
if wind_options['log_records'] > 0:
log_data = log_data[:wind_options['log_records']]
write_log(log_data)
### Data for graph log ###
try:
graph_data = read_graph_log()
except:
create_default_graph()
graph_data = read_graph_log()
timestamp = int(time_.time())
try:
maximum = graph_data[0]['balances']
maxval = {'total': get_all_values()[1]}
maximum.update({timestamp: maxval})
actual = graph_data[1]['balances']
actval = {'total': get_all_values()[0]}
actual.update({timestamp: actval})
write_graph_log(graph_data)
log.info(NAME, datetime_string() + ' ' + _(u'Saving to log files OK'))
except:
create_default_graph()
def GET(self):
global sender, status, avg_lst, avg_cnt, avg_rdy
qdict = web.input()
reset = helpers.get_input(qdict, 'reset', False, lambda x: True)
show = helpers.get_input(qdict, 'show', False, lambda x: True)
debug = helpers.get_input(qdict, 'debug', False, lambda x: True)
del_rain = helpers.get_input(qdict, 'del_rain', False, lambda x: True)
log_now = helpers.get_input(qdict, 'log_now', False, lambda x: True)
if sender is not None and reset:
status['minlevel'] = status['level']
status['maxlevel'] = status['level']
tank_options['saved_max'] = status['level']
tank_options['saved_min'] = status['level']
status['minlevel_datetime'] = datetime_string()
status['maxlevel_datetime'] = datetime_string()
log.info(
NAME,
datetime_string() + ': ' +
_(u'Minimum and maximum has reseted.'))
raise web.seeother(plugin_url(settings_page), True)
if sender is not None and log_now:
update_log()
if sender is not None and 'history' in qdict:
history = qdict['history']
tank_options.__setitem__('history', int(history))
if sender is not None and show:
raise web.seeother(plugin_url(log_page), True)
if sender is not None and debug:
raise web.seeother(plugin_url(log_debug_page), True)
if sender is not None and del_rain:
if NAME in rain_blocks:
del rain_blocks[NAME]
log.info(
NAME,
datetime_string() + ': ' + _(u'Removing Rain Delay') + '.')
raise web.seeother(plugin_url(settings_page), True)
return self.plugin_render.tank_monitor(tank_options, log.events(NAME))
def __init__(self):
Thread.__init__(self)
self.daemon = True
self._stop_event = Event()
global status, avg_lst, avg_cnt, avg_rdy
status['level'] = -1
status['percent'] = -1
status['ping'] = -1
status['volume'] = -1
status['maxlevel'] = tank_options['saved_max']
status['minlevel'] = tank_options['saved_min']
status['maxlevel_datetime'] = datetime_string()
status['minlevel_datetime'] = datetime_string()
self._sleep_time = 0
self.start()
def on_restart():
client = get_client()
time.sleep(2)
if client is not None:
publish_status("DOWN")
client.disconnect()
client.loop_stop()
client = None
log.info(NAME, datetime_string() + ' ' + _('Client stop'))
def update_log(status):
log_data = read_log()
data = {'datetime': datetime_string()}
for i in range(4):
data['ad%d' % i] = format(status['ad%d' % i], pcf_options['ad%d_temp' % i])
log_data.insert(0, data)
if pcf_options['log_records'] > 0:
log_data = log_data[:pcf_options['log_records']]
write_log(log_data)
def send_email(msg):
"""Send email"""
message = datetime_string() + ': ' + msg
try:
from plugins.email_notifications import email
email(message)
log.info(NAME, _('Email was sent') + ': ' + message)
except Exception:
log.info(NAME, _('Email was not sent') + '! ' + traceback.format_exc())
def on_stop():
client = get_client()
if client is not None:
status = "RunOnce Exit"
client.publish(plugin_options['publish_up_down'], status)
client.disconnect()
client.loop_stop()
client = None
log.info(NAME, datetime_string() + ' ' + _('Client on stop'))
def update_log():
"""Update data in json files."""
global sender
### Data for log ###
try:
log_data = read_log()
except:
write_log([])
log_data = read_log()
from datetime import datetime
data = {'datetime': datetime_string()}
data['date'] = str(datetime.now().strftime('%d.%m.%Y'))
data['time'] = str(datetime.now().strftime('%H:%M:%S'))
data['down'] = str(sender.status['down'])
data['up'] = str(sender.status['up'])
data['ping'] = str(sender.status['ping'])
log_data.insert(0, data)
if speed_options['log_records'] > 0:
log_data = log_data[:speed_options['log_records']]
try:
write_log(log_data)
except:
write_log([])
### Data for graph log ###
try:
graph_data = read_graph_log()
except:
create_default_graph()
graph_data = read_graph_log()
timestamp = int(time.time())
try:
downdata = graph_data[0]['balances']
downval = {'total': sender.status['down']}
downdata.update({timestamp: downval})
updata = graph_data[1]['balances']
upval = {'total': sender.status['up']}
updata.update({timestamp: upval})
pingdata = graph_data[2]['balances']
pingval = {'total': sender.status['ping']}
pingdata.update({timestamp: pingval})
write_graph_log(graph_data)
log.info(NAME, _('Saving to log files OK'))
except:
log.error(NAME,
_('Speed Monitor plug-in') + ':\n' + traceback.format_exc())
pass
def publish_status(status="RunOnce Ready"):
global last_status, flag_connected
client = get_client()
time.sleep(2)
if client and plugin_options["use_mqtt"]: # Publish message
if status != last_status:
last_status = status
log.info(NAME, datetime_string() + ' ' + _('Subscribing to topic') + ': ' + str(plugin_options['schedule_topic']))
client.subscribe(plugin_options['schedule_topic'])
client.publish(plugin_options['publish_up_down'], status)
def POST(self):
qdict = web.input(myfile={})
errorCode = qdict.get('errorCode', 'none')
#web.debug(qdict['myfile'].filename) # This is the filename
#web.debug(qdict['myfile'].value) # This is the file contents
#web.debug(qdict['myfile'].file.read()) # Or use a file(-like) object
try:
fname = qdict['myfile'].filename
upload_type = fname[-4:len(fname)]
types = ['.mp3', '.wav']
if upload_type not in types: # check file type is ok
log.info(
NAME,
datetime_string() + ': ' +
_(u'Error. File must be in mp3 or wav format!'))
errorCode = qdict.get('errorCode', 'Etype')
return self.plugin_render.voice_station_sounds(
plugin_options, errorCode)
else:
fout = open(os.path.join(plugin_data_dir(), fname),
'wb') # ASCI_convert(fname)
fout.write(qdict['myfile'].file.read())
fout.close()
log.info(
NAME,
datetime_string() + ': ' +
_(u'Uploading file sucesfully.'))
errorCode = qdict.get('errorCode', 'UplOK')
read_folder()
return self.plugin_render.voice_station_sounds(
plugin_options, errorCode)
except Exception:
log.error(
NAME,
_(u'Voice Station plug-in') + ':\n' + traceback.format_exc())
errorCode = qdict.get('errorCode', 'Eupl')
return self.plugin_render.voice_station_sounds(
plugin_options, errorCode)
raise web.seeother(plugin_url(sound_page), True)
def update_statistics(self):
"""Returns the statistics data."""
try:
import requests
link = "https://pihrt.com/ospystats/statistics.json"
req = requests.get(link)
bodytext = req.text
#log.debug(NAME, bodytext) # downloaded text
import json
jsonStr = json.loads(bodytext)
IDlenght = len(jsonStr['user'])
log.clear(NAME)
for i in range(0, IDlenght - 1):
log.info(NAME, _('ID') + ': ' + str(jsonStr['user'][i]['id']))
log.info(NAME,
_('Log') + ': ' + str(jsonStr['user'][i]['log']))
log.info(NAME,
_('OSPy') + ': ' + str(jsonStr['user'][i]['ospy']))
log.info(NAME,
_('CPU') + ': ' + str(jsonStr['user'][i]['cpu']))
log.info(
NAME,
_('Distribution') + ': ' +
str(jsonStr['user'][i]['distribution']))
log.info(
NAME,
_('System') + ': ' + str(jsonStr['user'][i]['system']))
log.info(
NAME,
_('Python') + ': ' + str(jsonStr['user'][i]['python']) +
'\n')
self.status['pageOK'] = _(
u'The data from') + ' www.pihrt.com ' + _(
u'was downloaded correctly.') + ' ' + datetime_string()
self.status['pageOKstate'] = True
try:
f = open("./ospy/statistics/user_id", "r")
userID = (f.read())
self.status['pageID'] = _(u'Your ID is: ') + str(userID)
except:
#log.error(NAME, _('Usage statistics plug-in') + ':\n' + traceback.format_exc())
pass
except Exception:
self.status['pageOK'] = _(
u'Error: data cannot be downloaded from') + ' www.pihrt.com!'
self.status['pageOKstate'] = False
log.clear(NAME)
def subscribe(topic, callback, qos=0):
"Subscribes to a topic with the given callback"
global _subscriptions
client = get_client()
if client and plugin_options["use_mqtt"]:
if topic not in _subscriptions:
_subscriptions[topic] = [callback]
client.subscribe(topic, qos)
log.info(NAME, datetime_string() + ' ' + _('Subscribe topic') + ': ' + str(topic))
else:
_subscriptions[topic].append(callback)
def __init__(self):
Thread.__init__(self)
self.daemon = True
self._stop_event = Event()
self.status = {}
self.status['meter'] = 0.0
self.status['kmeter'] = 0.0
self.status['max_meter'] = 0
self.status['log_date_maxspeed'] = datetime_string()
self._sleep_time = 0
self.start()
def POST(self):
global saved_emails
email_options.web_update(web.input())
qdict = web.input()
test = get_input(qdict, 'test', False, lambda x: True)
delete = get_input(qdict, 'del', False, lambda x: True)
if email_sender is not None:
email_sender.update()
if test:
body = datetime_string() + ': ' + _(u'This is test e-mail from OSPy. You can ignore it.')
logtext = _(u'This is test e-mail from OSPy. You can ignore it.')
try_mail(body, logtext)
if delete:
log.info(NAME, datetime_string() + ': ' + _(u'Email Queue was deleted.'))
write_email([])
saved_emails = 0
raise web.seeother(plugin_url(settings_page), True)
def get_all_values():
"""Return all posible values for others use."""
status = wind_sender.status
try:
if wind_options['use_kmh']:
return round(status['meter'] * 3.6,
2), round(status['max_meter'] * 3.6,
2), status['log_date_maxspeed'] # km/hod
else:
return round(status['meter'],
2), round(status['max_meter'],
2), status['log_date_maxspeed'] # m/sec
except:
return -1, -1, datetime_string()
def POST(self):
email_options.web_update(web.input())
qdict = web.input()
test = get_input(qdict, 'test', False, lambda x: True)
if email_sender is not None:
email_sender.update()
if test:
body = (datetime_string() +
': Test e-mail from e-mail notification plugin :-).')
email_sender.try_mail(body)
raise web.seeother(plugin_url(settings_page), True)
def notify_master_two_off(name, **kw):
log.info(NAME, datetime_string() + ': ' + _(u'Master station 2 stopped, counter finished...'))
master_two_stop = datetime.datetime.now()
master_two_time_delta = (master_two_stop - master_two_start).total_seconds()
difference = to_decimal(master_two_time_delta) * to_decimal(plugin_options['liter_per_sec_master_two'])
_sum = round(to_decimal(plugin_options['sum_two']), 2) + round(difference, 2) # to 2 places
plugin_options.__setitem__('sum_two', _sum)
msg = '<b>' + _(u'Water Consumption Counter plug-in') + '</b> ' + '<br><p style="color:green;">' + _(u'Water Consumption') + ' ' + str(round(difference,2)) + ' ' + _(u'liter') + '</p>'
msglog = _(u'Water Consumption Counter plug-in') + ': ' + _(u'Water Consumption for master 2') + ': ' + str(round(difference,2)) + ' ' + _(u'liter')
try:
if plugin_options['sendeml']:
send_email(msg, msglog)
except Exception:
log.error(NAME, _('Email was not sent') + '! ' + traceback.format_exc())
def GET(self):
global sender
qdict = web.input()
delete = helpers.get_input(qdict, 'delete', False, lambda x: True)
show = helpers.get_input(qdict, 'show', False, lambda x: True)
test = helpers.get_input(qdict, 'test', False, lambda x: True)
if sender is not None and delete:
write_log([])
create_default_graph()
raise web.seeother(plugin_url(settings_page), True)
if sender is not None and test:
log.clear(NAME)
try:
new_speeds = get_new_speeds()
sender._sleep(2)
tempText = _(
'Ping {} ms, Download {} Mb/s, Upload {} Mb/s').format(
sender.status['ping'], sender.status['down'],
sender.status['up'])
except:
new_speeds = 0, 0, 0
tempText = _('Cannot be loaded')
log.error(
NAME,
_('Speed Monitor plug-in') + ':\n' +
traceback.format_exc())
pass
sender.status['ping'] = new_speeds[0] # Ping (ms)
sender.status['down'] = new_speeds[1] # Download (Mb/s)
sender.status['up'] = new_speeds[2] # Upload (Mb/s)
log.info(
NAME,
datetime_string() + ' ' + _('Test button') + '\n' + tempText)
raise web.seeother(plugin_url(settings_page), True)
if sender is not None and 'history' in qdict:
history = qdict['history']
speed_options.__setitem__('history', int(history))
if sender is not None and show:
raise web.seeother(plugin_url(log_page), True)
return self.plugin_render.speed_monitor(speed_options,
log.events(NAME))
