def serial(self):
global sernum # save serial number
try:
self.log.info("READING SERIAL NUMBER")
file_system = FileSystemAccess(str("skills/KukiSkill/"))
file = file_system.open("kuki.serial", mode="r")
data = file.read()
file.close()
sernum = data # save data to sernum
self.log.info("SERIAL: " + sernum)
return sernum
except Exception as e:
self.log.error("SERIAL NOT READ FROM FILE")
self.log.error(e)
#return False
self.log.info("GENERATING NEW SERIAL NUMBER AND SAVE")
generate_serial(StringLength=56) # generate new serial number and save
self.log.info("SERIAL: " + sernum)
try:
file_system = FileSystemAccess(str("skills/KukiSkill/"))
file = file_system.open("kuki.serial", mode="w")
file.write(sernum)
file.close()
return True
except Exception as e:
self.log.error("SERIAL NOT SAVE TO FILE")
self.log.error(e)
return False
def update_credentials(self):
self.server = False # False for an ics file, true for a caldav server -regardless of where the creds are stored
self.no_creds = False
self.server = True
self.account = self.settings.get('username')
self.password = self.settings.get('password')
self.server = self.settings.get("server")
self.folder = self.settings.get('folder')
self.port = self.settings.get("port")
if self.account is None or self.account == "" or self.server is None or self.server == "":
# Using pw in config
fs = FileSystemAccess(str(self.skill_id))
if fs.exists("email_conf.yml"):
# Use yml file for config
config = fs.open("email_conf.yml", "r").read()
config = yaml.safe_load(config)
self.account = config.get("username")
self.password = config.get("password")
self.server = config.get("server_address")
self.folder = config.get("folder")
self.port = config.get("port")
else:
self.no_creds = True
if self.account is None or self.account == "":
self.no_creds = True
if self.no_creds is True:
# Not set up in file/home
self.speak_dialog("setup")
return False
return True
def search_manual(self, situation):
file_system = FileSystemAccess(str(self.skill_id))
file = file_system.open('troubleshooting.json', 'r')
data = json.load(file)
commonCauses = [li for li in data if li['name'] == situation]
commonCauses = commonCauses[0]['cause']
return commonCauses
def get_knowledge(self, filename):
file_system = FileSystemAccess(str(self.skill_id))
file = file_system.open(filename, "r")
data = []
for line in file:
data.append(line.rstrip('\n'))
knowledge = ".".join(data)
return knowledge
def save_data_json(self, filename, data, mode="w"):
try:
file_system = FileSystemAccess(str(self.skill_id))
file = file_system.open(filename, mode)
json.dump(data, file)
file.close()
return True
except Exception:
self.log.info("ERROR: could not save skill file " + filename)
return False
def save_data_file(self, filename, data, mode="w"):
try:
file_system = FileSystemAccess(str(self.skill_id))
file = file_system.open(filename, mode)
file.write(data)
file.close()
return True
except Exception: #as e
self.log.info("ERROR: could not save skill file " + filename)
#LOG.error(e)
return False
def save_knowledge(self, filename, knowledge, mode="w"):
data = knowledge.split(".")
data = "\n".join(data)
try:
file_system = FileSystemAccess(str(self.skill_id))
file = file_system.open(filename, mode)
file.write(data)
file.close()
return True
except Exception as e:
LOG.warning("could not save skill file " + filename)
LOG.error(e)
return False
class IdentityManager(object):
def __init__(self):
self.filesystem = FileSystemAccess('identity')
self.identity = None
self.initialize()
def initialize(self):
if self.filesystem.exists('identity.json'):
self.identity = DeviceIdentity.load(self.filesystem.open('identity.json', 'r'))
else:
identity = DeviceIdentity(device_id=str(uuid4()))
self.update(identity)
def update(self, identity):
self.identity = identity
with self.filesystem.open('identity.json', 'w') as f:
self.identity.save(f)
def is_paired(self):
return self.identity is not None and self.identity.owner is not None
def get(self):
return self.identity
class IdentityManager(object):
def __init__(self):
self.filesystem = FileSystemAccess('identity')
self.identity = None
self.initialize()
def initialize(self):
if self.filesystem.exists('identity.json'):
self.identity = DeviceIdentity.load(
self.filesystem.open('identity.json', 'r'))
else:
identity = DeviceIdentity(device_id=str(uuid4()))
self.update(identity)
def update(self, identity):
self.identity = identity
with self.filesystem.open('identity.json', 'w') as f:
self.identity.save(f)
def is_paired(self):
return self.identity is not None and self.identity.owner is not None
def get(self):
return self.identity
def write_file(self, filename, data):
fs = FileSystemAccess(str(self.skill_id))
data_file = fs.open(filename, "w")
data_file.writelines(data)
data_file.close()
return True
def read_file(self, filename):
fs = FileSystemAccess(str(self.skill_id))
data_file = fs.open(filename, "r")
data = data_file.read()
data_file.close()
return data
myRobot = str(
input('Please type the name of the robot you want to configure (None): ')
or 'None')
if myRobot != 'None':
for robot in account.robots:
if robot.name == myRobot:
n = base64.b64encode(robot.name.encode('ascii'))
snr = base64.b64encode(robot.serial.encode('ascii'))
sec = base64.b64encode(robot.secret.encode('ascii'))
credentials = {'n': n, 'snr': snr, 'sec': sec}
file_system = FileSystemAccess(join('skills', 'NeatoSkill'))
with file_system.open('credentials.store', 'wb') as f:
pickle.dump(credentials, f, pickle.HIGHEST_PROTOCOL)
print('Name: {}'.format(robot.name))
print('Serial: {}'.format(robot.serial))
print('Secret: {}'.format(robot.secret))
print('Created credentials.store for {} in {}'.format(
robot.name, file_system.path))
# Dump possible room configuration
dummy = account.maps
persMaps = account.persistent_maps
if robot.serial in persMaps:
maps = {}
myRobotsMaps = persMaps[robot.serial]
for mapData in myRobotsMaps:
