def activate():
uuid = request.json["state"]
from personal_mycroft_backend.settings import MAIL_USERNAME, MAIL_PASSWORD
# AUto pairing, hell yeah
with DeviceDatabase(SQL_DEVICES_URI, debug=DEBUG) as device_db:
device = device_db.get_unpaired_by_uuid(uuid)
if device is None:
return Response(
'Could not verify your access level for that URL.\n'
'You have to authenticate with proper credentials', 401,
{'WWW-Authenticate': 'Basic realm="NOT PAIRED"'})
user = device_db.get_user_by_uuid(uuid)
# create user if it doesnt exist
if not user:
device_db.add_user(MAIL_USERNAME,
MAIL_USERNAME.split("@")[0], MAIL_PASSWORD)
# auto pair!
device_db.add_device(uuid,
mail=MAIL_USERNAME,
expires_at=time.time() + 72000,
accessToken=gen_api(),
refreshToken=gen_api())
device_db.remove_unpaired(uuid)
result = model_to_dict(device_db.get_device_by_uuid(uuid))
print(result)
return nice_json(result)
def get_devices_json():
username = session['username']
with session_scope() as s:
user = s.query(User).filter(User.name.in_([username])).one()
if user is not None:
return [model_to_dict(d) for d in user.devices]
return []
def token():
api = request.headers.get('Authorization', '').replace("Bearer ", "")
with DeviceDatabase(SQL_DEVICES_URI, debug=DEBUG) as device_db:
device = device_db.get_device_by_token(api)
if not device:
return Response(
'Could not verify your access level for that URL.\n'
'You have to authenticate with proper credentials', 401,
{'WWW-Authenticate': 'Basic realm="NOT PAIRED"'})
# token to refresh expired token
if device.refreshToken is None or device.refreshToken != api:
return Response(
'Could not verify your access level for that URL.\n'
'You have to authenticate with proper credentials', 401,
{'WWW-Authenticate': 'Basic realm="BAD REFRESH CODE"'})
# new tokens to access
access_token = gen_api()
new_refresh_token = gen_api()
device_db.add_device(uuid=device.uuid,
expires_at=time.time() + 72000,
accessToken=access_token,
refreshToken=new_refresh_token)
result = model_to_dict(device)
return nice_json(result)
def device():
api = request.headers.get('Authorization', '').replace("Bearer ", "")
device = DEVICES.get_device_by_token(api)
if device is not None:
result = model_to_dict(device)
else:
result = {}
return nice_json(result)
def device():
api = request.headers.get('Authorization', '').replace("Bearer ", "")
with DeviceDatabase(SQL_DEVICES_URI, debug=DEBUG) as device_db:
device = device_db.get_device_by_token(api)
if device is not None:
result = model_to_dict(device)
else:
result = {}
return nice_json(result)
def as_dict(self):
# this is a placeholder
# TODO generate proper config matching mycroft.conf
bucket = {"module": self.name}
self_dict = model_to_dict(self)
for k in self_dict:
if k in ["engine_type", "name", "id"]:
continue
if self_dict[k]:
bucket[k] = self_dict[k]
return bucket
def get_location_json(uuid=None):
username = session['username']
with session_scope() as s:
if uuid:
device = s.query(Device).filter(Device.uuid == uuid).first()
return [model_to_dict(device.location)] or []
else:
user = s.query(User).filter(User.name.in_([username])).one()
if user is not None:
return [c.as_dict for c in user.locations]
return []
def get_uuid(uuid):
device = DEVICES.get_device_by_uuid(uuid)
if device is not None:
if request.method == 'PATCH':
result = request.json
DEVICES.add_device(uuid=uuid,
name=result.get("name"),
expires_at=result.get("expires_at"),
accessToken=result.get("accessToken"),
refreshToken=result.get("refreshToken"))
result = model_to_dict(device)
else:
result = {}
return nice_json(result)
def get_uuid(uuid):
with DeviceDatabase(SQL_DEVICES_URI, debug=DEBUG) as device_db:
device = device_db.get_device_by_uuid(uuid)
if device is not None:
if request.method == 'PATCH':
result = request.json
device_db.add_device(
uuid=uuid,
name=result.get("name"),
expires_at=result.get("expires_at"),
accessToken=result.get("accessToken"),
refreshToken=result.get("refreshToken"))
result = model_to_dict(device)
else:
result = {}
return nice_json(result)
def activate():
uuid = request.json["state"]
# paired?
device = DEVICES.get_device_by_uuid(uuid)
if device is None or not device.paired:
return Response(
'Could not verify your access level for that URL.\n'
'You have to authenticate with proper credentials', 401,
{'WWW-Authenticate': 'Basic realm="NOT PAIRED"'})
# generate access tokens
DEVICES.add_device(uuid=uuid,
expires_at=time.time() + 72000,
accessToken=gen_api(),
refreshToken=gen_api())
result = model_to_dict(device)
return nice_json(result)
def setting(uuid=""):
device = DEVICES.get_device_by_uuid(uuid)
if device is not None:
result = model_to_dict(device.config)
# format result
cleans = ["skills_dir", "skills_auto_update"]
blacklisted = [
skill.folder for skill in device.config.skills
if skill.blacklisted
]
priority = [
skill.folder for skill in device.config.skills
if skill.priority
]
result["skills"] = {
"directory": device.config.skills_dir,
"auto_update": device.config.skills_auto_update,
"blacklisted_skills": blacklisted,
"priority_skills": priority
}
cleans += [
"listener_energy_ratio", "record_wake_words",
"record_utterances", "wake_word_upload", "stand_up_word",
"wake_word", "listener_sample_rate", "listener_channels",
"listener_multiplier", "phoneme_duration"
]
result["listener"] = {
"sample_rate": result["listener_sample_rate"],
"channels": result["listener_channels"],
"record_wake_words": result["record_wake_words"],
"record_utterances": result["record_utterances"],
"phoneme_duration": result["phoneme_duration"],
"wake_word_upload": {
"enable": result["wake_word_upload"]
},
"multiplier": result["listener_multiplier"],
"energy_ratio": result["listener_energy_ratio"],
"wake_word": result["wake_word"],
"stand_up_word": result["stand_up_word"]
}
result["sounds"] = {}
for sound in device.config.sounds:
result["sounds"][sound.name] = sound.path
result["hotwords"] = {}
for word in device.config.hotwords:
result["hotwords"][word.name] = {
"module": word.module,
"phonemes": word.phonemes,
"threshold": word.threshold,
"lang": word.lang,
"active": word.active,
"listen": word.listen,
"utterance": word.utterance,
"sound": word.sound
}
stt = device.config.stt
creds = {}
if stt.engine_type == "token":
creds = {"token": stt.token}
elif stt.engine_type == "basic":
creds = {"username": stt.username, "password": stt.password}
elif stt.engine_type == "key":
creds = {
"client_id": stt.client_id,
"client_key": stt.client_key
}
elif stt.engine_type == "json":
creds = {"json": stt.client_id, "client_key": stt.client_key}
result["stt"] = {
"module": stt.name,
stt.name: {
"uri": stt.uri,
"lang": stt.lang,
"credential": creds
}
}
tts = device.config.tts
result["tts"] = {
"module": tts.name,
tts.name: {
"token": tts.token,
"lang": tts.lang,
"voice": tts.voice,
"gender": tts.gender,
"uri": tts.uri
}
}
if tts.engine_type == "token":
result["tts"][tts.name].merge({"token": tts.token})
elif tts.engine_type == "basic":
result["tts"][tts.name].merge({
"username": tts.username,
"password": tts.password
})
elif tts.engine_type == "key":
result["tts"][tts.name].merge({
"client_id": tts.client_id,
"client_key": tts.client_key
})
elif tts.engine_type == "api":
result["tts"][tts.name].merge({"api_key": tts.api_key})
for c in cleans:
result.pop(c)
else:
result = {}
return nice_json(result)
def as_dict(self):
# this is a placeholder
# TODO generate proper config matching mycroft.conf
bucket = model_to_dict(self)
return bucket
def sounds_as_dict(self):
# this is a placeholder
# TODO generate proper config matching mycroft.conf
return [model_to_dict(h) for h in self.sounds]
