def is_registered(self):
""" Check that the app is currently registered (granted) """
log(">>> is_registered")
if self._registered:
return True
self._registered = (self.get_registration_status() == 'granted')
return self._registered
def get_registration_status_diagnostic(self):
""" Get the current registration status and display diagnosic """
log(">>> get_registration_status_diagnostic")
status = self.get_registration_status()
track_id = self._conf.reg_params.get('track_id')
if 'granted' == status:
print('This app is already granted on Freebox Server' +
' (track_id={}).'.format(track_id) +
' You can now dialog with it.')
elif 'pending' == status:
print('This app grant is still pending: user should grant it' +
' on Freebox Server lcd/touchpad (track_id = {}).'.format(
track_id))
elif 'unknown' == status:
print(
'This track_id ({}) is unknown by Freebox Server: '.format(
track_id) +
'you have to register again to Freebox Server to get a new app_id.'
)
elif 'denied' == status:
print(
'This app has been denied by user on Freebox Server (track_id = {}).'
.format(self._conf.reg_params.get('track_id')))
elif 'timeout' == status:
print(
'Timeout occured for this app_id: you have to register again' +
' to Freebox Server to get a new app_id (current track_id = {}).'
.format(track_id))
else:
print('Unexpected response: {}'.format(status))
return status
def _set_wifi_radio_state(self, set_on):
""" Utility to activate or deactivate wifi radio module """
log('>>> set_wifi_radio_state {}'.format('ON' if set_on else 'OFF'))
# PUT wifi status
uri = '/wifi/config/'
data = {'enabled': True} if set_on else {'enabled': False}
timeout = 3 if not set_on else None
# PUT
try:
resp = self._http.put(uri, data=data, timeout=timeout)
except requests.exceptions.Timeout as exc:
if not set_on:
# If we are connected using wifi, disabling wifi will close connection
# thus PUT response will never be received: a timeout is expected
print('Wifi radio is now OFF')
return 0
else:
# Forward timeout exception as should not occur
raise exc
if not resp.success:
raise FbxException('Request failure: {}'.format(resp))
if self._conf.resp_as_json:
return resp.whole_content
is_on = resp.result.get('enabled')
print('Wifi radio is now {}'.format('ON' if is_on else 'OFF'))
return is_on
def get_registration_status(self):
""" Get the current registration status thanks to the track_id """
log(">>> get_registration_status")
if self._conf.has_registration_params():
uri = '/login/authorize/{}'.format(
self._conf.reg_params.get('track_id'))
resp = self._http.get(uri, no_login=True)
return resp.result.get('status')
else:
return "Not registered yet!"
def get_wifi_planning(self):
""" Get the current status of wifi: 1 means planning enabled, 0 means no planning """
log('>>> get_wifi_planning')
uri = '/wifi/planning/'
resp = self._http.get(uri)
if self._conf.resp_as_json:
return resp.whole_content
is_on = resp.success and resp.result.get('use_planning')
print('Wifi planning is {}'.format('ON' if is_on else 'OFF'))
return is_on
def get_wifi_radio_state(self):
""" Get the current status of wifi radio: 1 means ON, 0 means OFF """
log('>>> get_wifi_radio_state')
uri = '/wifi/config/'
resp = self._http.get(uri)
if self._conf.resp_as_json:
return resp.whole_content
is_on = resp.success and resp.result.get('enabled')
print('Wifi is {}'.format('ON' if is_on else 'OFF'))
return is_on
def mark_calls_as_read(self):
""" Mark all the calls as read """
log(">>> mark_calls_as_read")
uri = '/call/log/mark_all_as_read/'
data = {}
resp = self._http.post(uri, data)
if not resp.success:
raise FbxException('Request failure: {}'.format(resp))
# json response format
if self._conf.resp_as_json:
return resp.whole_content
return 0
def _set_wifi_planning(self, set_on):
""" Utility to activate or deactivate wifi planning mode """
log('>>> set_wifi_planning {}'.format('ON' if set_on else 'OFF'))
# PUT wifi planning
url = '/wifi/planning/'
data = {'use_planning': True} if set_on else {'use_planning': False}
resp = self._http.put(url, data=data)
if not resp.success:
raise FbxException('Request failure: {}'.format(resp))
if self._conf.resp_as_json:
return resp.whole_content
is_on = resp.result.get('use_planning')
print('Wifi planning is now {}'.format('ON' if is_on else 'OFF'))
return is_on
def register_app(self):
""" Register this app to FreeboxOS to that user grants this apps via Freebox Server
LCD screen. This command shall be executed only once. """
log(">>> register_app")
register = True
if self._conf.has_registration_params():
status = self.get_registration_status_diagnostic()
if 'granted' == status:
register = False
if register:
self._conf._load_addressing_params()
uri = '/login/authorize/'
data = self._conf.app_desc
# post it
resp = self._http.post(uri, data=data, no_login=True)
# save registration params
if resp.success:
params = {
'app_token': resp.result.get('app_token'),
'track_id': resp.result.get('track_id')
}
self._conf.reg_params = params
print(
'Now you have to accept this app on your Freebox server:' +
' take a look on its LCD screen.')
print(
input(
'Press Enter key once you have accepted on LCD screen: '
))
# check new status (it seems to be mandatory to reach in 'granted' state)
status = self.get_registration_status_diagnostic()
print('{}'.format('OK' if 'granted' == status else 'NOK'))
else:
print('NOK')
def get_all_calls_list(self):
""" List all the calls """
log(">>> get_all_calls_list")
return self._get_calls_list(False)
def get_new_calls_list(self):
""" List new calls """
log(">>> get_new_calls_list")
return self._get_calls_list(True)
def get_contacts(self):
""" List the port forwarding on going"""
def load_from_archive(svc):
contacts = FbxContacts(svc._ctrl, empty=True)
t_contacts = FbxDbTable(u'contact', u'id',
table_defs[u'contact'][u'cols_def'])
contacts.load_from_db(svc._ctrl, FbxContact, t_contacts)
return contacts
if self._conf.resp_archive:
self._contacts = load_from_archive(self)
else:
self._contacts = FbxContacts(self._ctrl)
if len(self._contacts) == 0:
if not self._conf.resp_restore:
print('No port contacts')
return 0
if self._conf.resp_restore:
self._contacts = FbxContacts(self._ctrl)
# clean before populate
for contact in self._contacts:
data = {}
url = u'/contact/{}'.format(contact.id)
resp = self._http.delete(url, data=data)
self._contacts = load_from_archive(self)
i = 0
for contact in self._contacts:
i += 1
# populate
data = {
u"display_name": contact.display_name,
u"first_name": contact.first_name,
u"last_name": contact.last_name,
u"birthday": contact.birthday,
u"notes": contact.notes,
u"company": contact.company,
u"photo_url": contact.photo_url,
}
# print(u'Restore', data)
url = u'/contact/'
resp = self._http.post(url, data=data)
client_id = resp.result['id']
# print(resp.result)
# print(client_id)
if not resp.success:
raise FbxException('Request failure: {}'.format(resp))
if contact.numbers is not None:
for number in contact.numbers:
# print(u'number: {}'.format(number))
data = {
u"contact_id": client_id,
u"number": number.number,
u"type": number.nbr_type,
u"is_default": number.is_default,
u"is_own": number.is_own,
}
url = u'/number/'
resp = self._http.post(url, data=data)
print(resp.result)
if contact.addresses is not None:
for address in contact.addresses:
# print(u'address: {}'.format(address))
data = {
u"contact_id": client_id,
u"street": address.street,
u"type": address.address_type,
u"city": address.city,
u"zipcode": address.zipcode,
u"number": address.number,
u"country": address.country,
u"street2": address.street2,
}
url = u'/address/'
resp = self._http.post(url, data=data)
print(resp.result)
if contact.emails is not None:
for email in contact.emails:
# print(u'email: {}'.format(email))
data = {
u"contact_id": client_id,
u"email": email.email,
u"type": email.email_type,
}
url = u'/email/'
resp = self._http.post(url, data=data)
print(resp.result)
if contact.urls is not None:
for url in contact.urls:
# print(u'url: {}'.format(url))
data = {
u"contact_id": client_id,
u"url": url.url,
u"type": url.url_type,
}
url = u'/url/'
resp = self._http.post(url, data=data)
print(resp.result)
# if i > 5: exit(0)
return 0
if self._conf.resp_as_json is False:
print('{} contacts'.format(len(self._contacts)))
if self._conf.resp_save:
# todo : save to archive
self._contacts.save_to_db()
if self._conf.resp_as_json and self._conf.resp_archive is False:
return self._contacts.json
tcount = 0
log(">>> get_contacts")
print(u'Contacts')
count = 0
for contact in self._contacts:
count += 1
tcount += 1
print(u'{}# {}'.format(count, contact))
return tcount > 0
def get_port_forwardings(self):
""" List the port forwarding on going"""
def load_from_archive(svc):
pfwds = FbxPortForwardings(svc._ctrl, empty=True)
t_pfwds = FbxDbTable(u'fw_redir', u'id',
table_defs[u'fw_redir'][u'cols_def'])
pfwds.load_from_db(svc._ctrl, FbxPortForwarding, t_pfwds)
return pfwds
if self._conf.resp_archive:
self._pfwds = load_from_archive(self)
else:
self._pfwds = FbxPortForwardings(self._ctrl)
if len(self._pfwds) == 0:
print('No port forwardings')
return 0
if self._conf.resp_restore:
self._pfwds_arc = load_from_archive(self)
# look for missing port forwardings
print(u'\nMissing port forwardings')
for pwd_arc in self._pfwds_arc:
pwd_fbx = self._pfwds.get_by_id(pwd_arc.id)
if pwd_fbx is None:
print(pwd_arc)
if fbx_question_yn(u'Restore'):
data = {
u"enabled": pwd_arc.enabled,
u"comment": pwd_arc.comment,
u"lan_port": pwd_arc.lan_port,
u"wan_port_end": pwd_arc.wan_port_end,
u"wan_port_start": pwd_arc.wan_port_start,
u"lan_ip": pwd_arc.lan_ip,
u"ip_proto": pwd_arc.ip_proto,
u"src_ip": pwd_arc.src_ip,
}
print(u'Restore', data)
url = u'/fw/redir/'
resp = self._http.post(url, data=data)
if not resp.success:
raise FbxException(
'Request failure: {}'.format(resp))
return 0
if self._conf.resp_as_json is False:
print('{} port forwardings'.format(len(self._pfwds)))
if self._conf.resp_save:
# todo : save to archive
self._pfwds.save_to_db()
if self._conf.resp_as_json and self._conf.resp_archive is False:
return self._pfwds.json
tcount = 0
log(">>> get_enabled_port_forwarding")
print(u'Enabled port forwardings')
count = 0
for pfwd in self._pfwds:
if pfwd.enabled is False:
continue
count += 1
tcount += 1
# pfwd to be displayed
print(u'{}# {}'.format(count, pfwd))
log(">>> get_disabled_port_forwarding")
print(u'Disabled port forwardings')
count = 0
for pfwd in self._pfwds:
if pfwd.enabled is True:
continue
count += 1
tcount += 1
# pfwd to be displayed
print(u'{}# {}'.format(count, pfwd))
return tcount > 0
def get_dhcp_leases(self):
""" List the DHCP dynamic leases on going"""
log(">>> get_dynamic_leases")
self._st_leases = FbxDhcpStaticLeases(self._ctrl)
if self._conf.resp_archive:
self._dyn_leases = FbxDhcpDynamicLeases(self._ctrl, empty=True)
t_dyn_leases = FbxDbTable(
u'dynamic_lease', u'mac',
table_defs[u'dynamic_lease'][u'cols_def'])
self._dyn_leases.load_from_db(self._ctrl, FbxDhcpDynamicLease,
t_dyn_leases)
else:
self._dyn_leases = FbxDhcpDynamicLeasesX(self._ctrl,
self._st_leases)
if len(self._dyn_leases) == 0:
print('No DHCP leases')
return 0
if self._conf.resp_as_json is False:
print('{} DHCP leases'.format(len(self._dyn_leases)))
if self._conf.resp_save:
self._dyn_leases.save_to_db()
if self._conf.resp_as_json and self._conf.resp_archive is False:
return self._dyn_leases.json
tcount = 0
count = 0
print('\nList of reachable leases:')
for dyn_lease in self._dyn_leases:
if dyn_lease.reachable is False:
continue
count += 1
tcount += 1
# st_lease to be displayed
print(u'{}# {}'.format(count, dyn_lease))
count = 0
print('\nList of unreachable leases:')
for dyn_lease in self._dyn_leases:
if dyn_lease.reachable:
continue
count += 1
tcount += 1
# st_lease to be displayed
print(u'{}# {}'.format(count, dyn_lease))
return tcount > 0
return
if self._conf.resp_restore:
for k, v in self._arc_o_dict.items():
""" Create static lease"""
if (k not in self._fbx_o_dict.keys()) and v.is_static:
print(v)
""" Restore Y/N"""
to_restore = False
answer = None
while answer not in ("y", "n", "Y", "N", "o", "O"):
answer = input(u"Restore Y/N): ")
if answer in ("y", "Y", "o", "O"):
to_restore = True
elif answer in ("n", "N"):
to_restore = False
if to_restore:
""" Create missing static lease"""
uri = u'/dhcp/static_lease/'
data = {"mac": v.mac, "ip": v.ip, "comment": v.comment}
resp = self._http.post(uri, data)
if not resp.success:
uri = u'/dhcp/static_lease/{}'.format(v.mac)
data = {"ip": v.ip, "comment": v.comment}
resp = self._http.put(uri, data)
if not resp.success:
print(u'Create failed')
print(u'Updated')
continue
print(u'Created')
""" Update static lease"""
if (k in self._fbx_o_dict.keys()) and v.is_static:
# todo : compare v with self._fbx_o_dict[k]
to_update = False
ofbx = self._fbx_o_dict[k]
# print(ofbx.comment, v.comment)
if (ofbx.comment != v.comment) or (ofbx.ip != v.ip):
to_update = True
if to_update:
print(v, u'\n Archive:\n', ofbx)
to_restore = False
answer = None
while answer not in ("y", "n", "Y", "N", "o", "O"):
answer = input(u"Update Y/N): ")
if answer in ("y", "Y", "o", "O"):
to_restore = True
elif answer in ("n", "N"):
to_restore = False
if to_restore:
""" Create missing static lease"""
uri = u'/dhcp/static_lease/{}'.format(v.mac)
data = {"ip": v.ip, "comment": v.comment}
resp = self._http.put(uri, data)
if not resp.success:
print(u'Update failed')
return
log(">>> get_dhcp_leases")
# GET dhcp leases
uri = '/dhcp/dynamic_lease/'
resp = self._http.get(uri)
if not resp.success:
raise FbxException('Request failure: {}'.format(resp))
# json response format
if self._conf.resp_as_json:
return resp.whole_content
# human response format
leases = resp.result
if leases is None:
print('No DHCP leases')
return 0
count = self.save_to_archive(FbxDhcpDynamicLease, leases)
count = 1
# To do : use self._fbx_o_dict
for olease in self._fbx_o_dict.values():
print(u' #{}: {}'.format(count, olease))
count += 1
return
count = 1
for lease in leases:
if 'host' in lease and lease.get('host').get('reachable'):
olease = FbxDhcpDynamicLease(self, lease)
print(u' #{}: {}'.format(count, olease))
count += 1
count = 1
print('List of unreachable leases:')
for lease in leases:
if 'host' in lease and not lease.get('host').get('reachable'):
olease = FbxDhcpDynamicLease(self, lease)
print(u' #{}: {}'.format(count, olease))
count += 1
count = 1
print('List of other leases:')
for lease in leases:
if 'host' not in lease:
olease = FbxDhcpDynamicLease(self, lease)
print(u' #{}: {}'.format(count, olease))
count += 1
return 0
def get_static_leases(self):
""" List the DHCP leases on going"""
log(">>> get_static_leases")
self._dyn_leases = FbxDhcpDynamicLeases(self._ctrl)
def load_from_archive(svc):
st_leases = FbxDhcpStaticLeases(svc._ctrl, empty=True)
t_st_leases = FbxDbTable(u'static_lease', u'id',
table_defs[u'static_lease'][u'cols_def'])
st_leases.load_from_db(svc._ctrl, FbxDhcpStaticLease, t_st_leases)
return st_leases
if self._conf.resp_archive:
self._st_leases = load_from_archive(self)
else:
self._st_leases = FbxDhcpStaticLeasesX(self._ctrl,
self._dyn_leases)
if self._conf.resp_restore:
self._st_leases_arc = load_from_archive(self)
# look for missing static leases
print(u'\nMissing leases')
for st_lease_arc in self._st_leases_arc:
st_lease_fbx = self._st_leases.get_by_id(st_lease_arc.mac)
if st_lease_fbx is None:
print(st_lease_arc)
if fbx_question_yn(u'Restore'):
data = {
u"mac": st_lease_arc.mac,
u"ip": st_lease_arc.ip,
u"comment": st_lease_arc.comment
}
print(u'Restore', data)
url = u'/dhcp/static_lease/'
resp = self._http.post(url, data=data)
if not resp.success:
raise FbxException(
'Request failure: {}'.format(resp))
# look for leases to update
print(u'\nLeases to update')
for st_lease_arc in self._st_leases_arc:
st_lease_fbx = self._st_leases.get_by_id(st_lease_arc.mac)
if st_lease_fbx is not None:
data = {u"mac": st_lease_arc.mac}
to_restore = False
for key in [u'ip', u'comment']:
if getattr(st_lease_arc, key) != getattr(
st_lease_fbx, key):
to_restore = True
data[key] = getattr(st_lease_arc, key)
if to_restore:
print(st_lease_arc)
print(st_lease_fbx)
print(data)
if fbx_question_yn(u'Update'):
print(u'Update', data)
url = u'/dhcp/static_lease/{}'.format(
st_lease_arc.mac)
resp = self._http.put(url, data=data)
if not resp.success:
raise FbxException(
'Request failure: {}'.format(resp))
return 0
if self._conf.resp_save:
self._st_leases.save_to_db()
if self._conf.resp_as_json and self._conf.resp_archive is False:
return self._st_leases.json
count = 0
# for new call only, we display new calls only
for st_lease in self._st_leases:
# if new_only and call.new is False:
# continue
count += 1
# st_lease to be displayed
print(u'{}# {}'.format(count, st_lease))
return count > 0
def reboot(self):
""" Reboot the freebox server now! """
log(">>> reboot")
uri = '/system/reboot/'
self._http.post(uri, timeout=3)
return True
