def url_updater():
#
updatestatus = False
#
while True:
#
try:
eml_lists = eml_list()
#
if len(eml_lists) > 0:
#
eml_ids = get_ids(eml_lists)
#
if len(eml_ids) > 0:
#
emls = get_emails(eml_ids)
updatestatus = process_emls(emls)
#
if updatestatus:
msg_success = 'the url stored in config.json has been updated'
else:
msg_success = 'no new urls received'
log_general(
'Axiscare URL updater process completed - {msg_success}'.
format(msg_success=msg_success))
#
except Exception as e:
log_error(
'Could not process emails to check for new URL notification - {error}'
.format(error=e))
#
time.sleep(300) #5mins
def cache_tvchannels():
log = log_msg(request, uri_cache_tvchannels)
try:
log_general(log)
return HTTPResponse(body=compile_tvchannels(), status=200)
except Exception as e:
log_error('{log} - {error}'.format(log=log, error=e))
return HTTPResponse(status=404)
def send_favicon():
log = log_msg(request, uri_favicon)
try:
root = os.path.join(os.path.dirname(__file__), 'imgs/logo')
log_general(log)
return static_file('favicon.ico', root=root)
except Exception as e:
log_error('{log} - {error}'.format(log=log, error=e))
raise HTTPError(500)
def user_checkpin():
log = log_msg(request, uri_user_pin)
check = check_pin(request.json['user'], request.json['pin'])
if check:
log_general('{log} - {user} - {passfail}'.format(
log=log, user=request.json['user'], passfail='pass'))
return HTTPResponse(status=200)
else:
log_general('{log} - {user} - {passfail}'.format(
log=log, user=request.json['user'], passfail='fail'))
return HTTPResponse(status=401)
def get_image(category, filename):
log = log_msg(request, uri_image)
try:
root = os.path.join(os.path.dirname(__file__),
'imgs/{img_cat}'.format(img_cat=category))
mimetype = filename.split('.')[1]
log_general(log)
return static_file(
filename,
root=root,
mimetype='image/{mimetype}'.format(mimetype=mimetype))
except Exception as e:
log_error('{log} - {error}'.format(log=log, error=e))
raise HTTPError(500)
def cache_subscribe():
log = log_msg(request, uri_cache_subscribe)
try:
#
r = request
#
categories = request.json['categories']
ipaddress = request.json['ipaddress']
port = request.json['port']
#
log_general(log)
return HTTPResponse(status=200)
except Exception as e:
log_error('{log} - {error}'.format(log=log, error=e))
return HTTPResponse(status=404)
def getForcast(frequency):
# frequency = '3hourly' or 'daily'
url = '{url}{uri}?res={frequency}&key={key}'.format(url=BASE_URL,
uri=URI_FORECAST_SITE.format(datatype='json',
locationId=LOCATION_id),
frequency=frequency,
key=get_config_weather_metoffice_appkey())
r = requests.get(url)
#
if r.status_code == requests.codes.ok:
log_general('Met Office weather forecast data retrieved successfully for frequency {frequency}'.format(frequency=frequency))
return r.json()
else:
log_error('Could not retrieve Met Office weather forecast for frequency {frequency}'.format(frequency=frequency))
return False
def get_data_infoservice(service=False, resource_requested=False):
#
global infoservices
#
log = log_msg(request, uri_data_infoservice)
#
try:
#
if (not service) or (not resource_requested):
log_error('{log} - {error}'.format(log=log, error='URI invalid'))
raise HTTPError(404)
#
try:
info_seq = get_cfg_info_seq(service)
except Exception as e:
log_error('{log} - {error}'.format(log=log, error=e))
raise HTTPError(404)
#
data_dict = {'data': resource_requested}
#
if len(request.query.decode()) > 0:
data_dict.update(request.query.decode())
#
#
rsp = infoservices[info_seq].getData(data_dict)
#
response = HTTPResponse()
enable_cors(response)
#
if isinstance(rsp, bool):
if rsp:
response.status = 200
else:
response.status = 400
else:
if bool(rsp):
response.body = str(rsp)
response.status = 200
else:
response.status = 400
#
log_general(log)
return response
#
except Exception as e:
log_error('{log} - {error}'.format(log=log, error=e))
raise HTTPError(500)
def _getNewToken(self):
#
try:
#
token_response = get_accesstoken(self._clientid(),
self._clientsecret(),
self._pincode())
#
log_general('Success retrieving new Access Token', dvc_id=self.dvc_id())
#
self._set_token(token_response['token'])
self._set_tokenexpiry(token_response['tokenexpiry'])
#
return True
#
except:
return False
def getSunRiseSet(date, latitude, longitude):
url = '{url}{uri}'.format(url=BASE_URL,
uri=QUERY_REQUEST.format(lat=latitude,
lng=longitude,
date=date))
r = requests.get(url)
#
if r.status_code == requests.codes.ok:
log_general(
'Sunset-Sunrise weather forecast data retrieved successfully for date {date}'
.format(date=date))
return r.json()
else:
log_error(
'Could not retrieve Sunset-Sunrise data for date {date}'.format(
date=date))
return {'status': 'ERROR'}
def _retrieve_recordings(self, recurse, itemCount=''):
try:
r = self.tivoSession.get(
'https://{ipaddress}/TiVoConnect?Command=QueryContainer&Container=%2FNowPlaying&Recurse={recurse}{itemCount}'
.format(ipaddress=self._ipaddress(),
recurse=recurse,
itemCount=itemCount))
log_msg = create_device_log_message(
'retrieve listings (recurse={recurse})'.format(
recurse=recurse), self._type, self._ipaddress(),
r.status_code)
log_general(log_msg, dvc_id=self.dvc_id())
if r.status_code == requests.codes.ok:
return r.content
else:
return False
except Exception as e:
return False
def _getlisting(self, data):
#
listing_srcs = data['listingsrc']
#
if not listing_srcs:
log_warning(
'No sources available to retrieve listings for {channel}'.
format(channel=data['name']))
return {}
#
if len(listing_srcs) > 0:
for src, code in listing_srcs.items():
try:
if src == 'bleb':
log_general(
'TV listing for {channel} being retrieved from {src}'
.format(channel=data['name'], src=src))
return data_source_bleb.get(code)
except Exception as e:
log_error(
'TV listing for {channel} failed to be retrieved from {src} - {error}'
.format(channel=data['name'], src=src, error=e))
return {}
def send_command_device(group=False, thing=False):
#
global devices
#
log = log_msg(request, uri_command_device)
#
try:
#
if (not group) or (not thing):
log_error('{log} - {error}'.format(log=log, error='URI invalid'))
raise HTTPError(404)
#
try:
group_seq = get_cfg_group_seq(group)
thing_seq = get_cfg_thing_seq(group, thing)
except Exception as e:
log_error('{log} - {error}'.format(log=log, error=e))
raise HTTPError(404)
#
cmd_dict = request.json
#
rsp = devices[group_seq][thing_seq].sendCmd(cmd_dict)
#
log_general(log)
#
if isinstance(rsp, bool):
return HTTPResponse(status=200) if rsp else HTTPResponse(
status=400)
else:
return HTTPResponse(body=str(rsp),
status=200) if bool(rsp) else HTTPResponse(
status=400)
#
except Exception as e:
log_error('{log} - {error}'.format(log=log, error=e))
raise HTTPError(500)
def get_data_device(group=False, thing=False, resource_requested=False):
#
global devices
#
log = log_msg(request, uri_data_device)
#
try:
#
if (not group) or (not thing) or (not resource_requested):
log_error('{log} - {error}'.format(log=log, error='URI invalid'))
raise HTTPError(404)
#
try:
group_seq = get_cfg_group_seq(group)
thing_seq = get_cfg_thing_seq(group, thing)
except Exception as e:
log_error('{log} - {error}'.format(log=log, error=e))
raise HTTPError(404)
#
data_dict = {'data': resource_requested}
#
rsp = devices[group_seq][thing_seq].getData(data_dict)
#
log_general(log)
#
if isinstance(rsp, bool):
return HTTPResponse(status=200) if rsp else HTTPResponse(
status=400)
else:
return HTTPResponse(body=str(rsp),
status=200) if bool(rsp) else HTTPResponse(
status=400)
#
except Exception as e:
log_error('{log} - {error}'.format(log=log, error=e))
raise HTTPError(500)
def sendCmd(self, request):
#
try:
msg_command = ''
code = False
response = False
#
if request['command'] == 'enterpin':
msg_command = 'enterpin'
try:
rsp = []
for num in self._pin():
code = self.commands[num]
rsp.append(
self._send_telnet(self._ipaddress(),
self._port(),
data=code))
log_msg = create_device_log_message(
code, self._type, self._ipaddress(), response)
log_general(log_msg, dvc_id=self.dvc_id())
response = not (False in rsp)
except Exception as e:
response = False
elif request['command'] == 'channel':
msg_command = request['chan']
response = self._send_telnet(ipaddress=self._ipaddress(),
port=self._port(),
data=("SETCH {}\r").format(
request['chan']),
response=True)
if response.startswith('CH_FAILED'):
log_msg = create_device_log_message(
'channel', self._type, self._ipaddress(), response)
log_general(log_msg, dvc_id=self.dvc_id())
return False
elif request['command'] == 'command':
msg_command = request['code']
code = self.commands[request['code']]
try:
response = self._send_telnet(self._ipaddress(),
self._port(),
data=code)
except:
response = False
#
log_msg = create_device_log_message(msg_command, self._type,
self._ipaddress(), response)
log_general(log_msg, dvc_id=self.dvc_id())
return response
except Exception as e:
log_msg = create_device_log_message(request['command'], self._type,
self._ipaddress(), e)
log_error(log_msg, dvc_id=self.dvc_id())
return False
def create_bindings(_things, _infoservices):
#
data = get_cfg_bindings_json()
#
for group in data['bindings']['groups']:
#
_things[group['sequence']] = {}
group_things = {}
#
for thing in group['things']:
#
try:
group_things[thing['sequence']] = _create_thing(
thing['type'], group['sequence'], thing['sequence'])
log_general('Thing created: {type}: {group}:{thing}'.format(
type=thing['type'],
group=group['name'],
thing=thing['name']))
except Exception as e:
log_error(
'Coud not create Thing: {type}: {group}:{thing}'.format(
type=thing['type'],
group=group['name'],
thing=thing['name']))
#
#
_things[group['sequence']] = group_things
#
#
for info in data['bindings']['info_services']:
#
try:
_infoservices[info['sequence']] = _create_info(
info['type'], info['sequence'])
log_general('Info_service created: {type}: {info}'.format(
type=info['type'], info=info['name']))
except Exception as e:
log_error('Coud not create Info_service: {type}: {info}'.format(
type=info['type'], info=info['name']))
#
#
log_general('All instances of Things and Info_services created')
def get_recordings(self):
# Reset value
self.recordings = False
#
try:
#
############
#
folders = self._retrieve_recordings('No').replace(
' xmlns="http://www.tivo.com/developer/calypso-protocol-1.6/"',
'')
folders = ET.fromstring(folders)
xml_folders = []
for item in folders.iter('Item'):
xml_folders.append(item.find('Details'))
#
############
#
retrieve_items = 50
#
files_repeat = True
loop_count = 0
itemCount = '&ItemCount={retrieve_items}'.format(
retrieve_items=retrieve_items)
xml_files = []
#
while files_repeat:
files_count = 0
files = self._retrieve_recordings(
'Yes', itemCount=itemCount
).replace(
' xmlns="http://www.tivo.com/developer/calypso-protocol-1.6/"',
'')
files = ET.fromstring(files)
# Run through individual items
for item in files.iter('Item'):
xml_files.append(item.find('Details'))
files_count += 1
#
if files_count < 50:
files_repeat = False
else:
loop_count += 1
itemCount = '&ItemCount={retrieve_items}&AnchorOffset={AnchorOffset}'.format(
retrieve_items=retrieve_items,
AnchorOffset=(retrieve_items * loop_count))
#
############
#
self.recordings_timestamp = datetime.datetime.now()
self.recordings = self._create_recordings_json(
self.recordings_timestamp, xml_folders, xml_files)
#
############
#
log_general('TV recording information retrieved: {type}'.format(
type=self._type),
dvc_id=self.dvc_id())
#
except Exception as e:
log_error(
'Error retrieving TV recording information: {type} - {error}'.
format(type=self._type, error=e),
dvc_id=self.dvc_id())
self.recordings_timestamp = 0
self.recordings = False
def run_bottle(self_port):
host = '0.0.0.0'
log_general('Bottle started: listening on {host}:{port}'.format(
host=host, port=self_port))
run(host=host, port=self_port, debug=True)
def _tokencheck(self):
log_general('Checking Auth Token', dvc_id=self.dvc_id())
if self._checkToken():
return True
else:
return self._getNewToken()
def start_url_updater():
process_urlupdater = Process(target=url_updater)
process_urlupdater.start()
log_general('Axiscare URL updater process started')
import sys
from bottle import error, HTTPError, get, run, static_file, HTTPResponse
from web.web_create_error import create_error
from web.web_create_home import create_home
from log.log import log_general, log_error
from axiscare.url_process import start_url_updater
from axiscare.carer_info import carer_info, carers_today
from weather.weather import obj_weather
from messages.message_info import messages_current
################################################################################################
log_general('****************************************************************')
log_general('Operation started')
################################
# Receive sys arguments
################################
# First argument passed through is the
# port the application listens on
try:
self_port = sys.argv[1]
except:
self_port = 8080 # default port
#
host = '0.0.0.0'
#
################################################################################################
import time
from ip.ip_lookup import get_ip
from ip.ip_previous import get_last_ip, set_last_ip
from notify.notify import send_ip
from log.log import log_general, log_warning, log_error
try:
#
log_general('Operation started')
#
while True:
#
# Get last & current ip
last_ip = get_last_ip()
current_ip = get_ip()
#
if current_ip:
if not last_ip == current_ip:
e = send_ip(current_ip)
if e:
set_last_ip(current_ip)
log_general(
'Emails sent with new IP address ({ip})'.format(
ip=current_ip))
else:
log_warning(
'Failure to send emails with new IP address ({ip})'.
format(ip=current_ip))
else:
log_warning('Current IP failed to be retrieved')
#
# Receive sys arguments
################################
# First argument passed through is the
# port the application listens on
try:
self_port = sys.argv[1]
except:
self_port = 1600 # default port
#
################################
# Process for object creation
################################
_things = Manager().dict()
_infoservices = Manager().dict()
#
log_general('Starting process: Device, account and infoservice object creation')
process_object = Process(target=create_bindings, args=(_things, _infoservices, ))
process_object.start()
log_general('Process started: Device, account and infoservice object creation')
#
################################
# Process for port_listener
################################
log_general('Starting process: "bottle" server for port {port}'.format(port=self_port))
process_bottle = Process(target=start_bottle, args=(_things, _infoservices, self_port, ))
process_bottle.start()
log_general('Process started: "bottle" server for port {port}'.format(port=self_port))
#
################################
process_object.join()
process_bottle.join()
