def code():
uuid = request.args["state"]
code = generate_code()
print code
DEVICES.add_unpaired_device(uuid, code)
result = {"code": code, "uuid": uuid}
return nice_json(result)
def get_subscriber_voice_url(uuid=""):
arch = request.args["arch"]
device = DEVICES.get_device_by_uuid(uuid)
if device is not None:
device.arch = arch
DEVICES.commit()
return nice_json({"link": ""})
def metric(uuid="", name=""):
data = request.json
print name, data
device = DEVICES.get_device_by_uuid(uuid)
if device is None:
return
DEVICES.add_metric(name=name, uuid=uuid, data=data)
def pair(code, name="unknown_device"):
device = DEVICES.get_unpaired_by_code(code)
if device:
user = get_user()
if DEVICES.add_device(uuid=device.uuid, name=name, mail=user.mail):
DEVICES.remove_unpaired(device.uuid)
msg = Message("Device was paired", recipients=[user.mail])
mail.send(msg)
return True
return False
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 subscription_type(uuid=""):
sub_type = "free"
device = DEVICES.get_device_by_uuid(uuid)
if device is not None:
sub_type = device.subscription
subscription = {"@type": sub_type}
return nice_json(subscription)
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 get_uuid(uuid):
device = DEVICES.get_device_by_uuid(uuid)
if device is not None:
if request.method == 'PATCH':
result = request.json
print result
DEVICES.patch_device(
uuid=uuid,
coreVersion=result.get("coreVersion"),
platform=result.get("platform"),
platform_build=result.get("platform_build"),
enclosureVersion=result.get("enclosureVersion"))
result = model_to_dict(device)
else:
result = {}
return nice_json(result)
def check_auth(api_key):
"""This function is called to check if a api key is valid."""
device = DEVICES.get_device_by_token(api_key)
if not device:
return False
if device.expires_at < time.time():
return False
return True
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 send_mail(uuid=""):
data = request.json
user = DEVICES.get_user_by_uuid(uuid)
if user is not None:
message = data["body"]
subject = data["title"]
msg = Message(recipients=[user.email],
body=message,
subject=subject,
sender=data["sender"])
mail.send(msg)
def location(uuid):
device = DEVICES.get_device_by_uuid(uuid)
if device is None:
return nice_json({"error": "device not found"})
if device.location.timezone is None:
if not request.headers.getlist("X-Forwarded-For"):
ip = request.remote_addr
else:
# TODO http://esd.io/blog/flask-apps-heroku-real-ip-spoofing.html
ip = request.headers.getlist("X-Forwarded-For")[0]
DEVICES.add_ip(uuid, ip)
new_location = geo_locate(ip)
DEVICES.add_location(uuid, new_location)
return nice_json(new_location)
location = device.location
result = location_dict(location.city, location.region_code,
location.country_code, location.country_name,
location.region, location.longitude,
location.latitude, location.timezone)
return nice_json(result)
def pair(code, uuid, name, mail):
# pair
result = {"paired": False}
device = DEVICES.get_unpaired_by_uuid(uuid)
if device and device.code == code:
user = DEVICES.get_user_by_mail(mail)
# create user if it doesnt exist
if not user:
DEVICES.add_user(mail, name, "666")
if DEVICES.add_device(uuid, mail=mail):
DEVICES.remove_unpaired(uuid)
result = {"paired": True}
return nice_json(result)
def token():
api = request.headers.get('Authorization', '').replace("Bearer ", "")
device = DEVICES.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()
DEVICES.add_device(uuid=device.uuid,
expires_at=time.time() + 72000,
accessToken=access_token,
refreshToken=new_refresh_token)
return nice_json(model_to_dict(device))
def setting(uuid=""):
device = DEVICES.get_device_by_uuid(uuid)
if device is not None:
result = model_to_dict(device.config)
# format results
# skills
cleans = ["skills_dir", "skills_auto_update", "device_id", "id"]
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
}
# location
location = device.location
result["location"] = location_dict(location.city, location.region_code,
location.country_code,
location.country_name,
location.region, location.longitude,
location.latitude,
location.timezone)
# listener
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"]
}
# sounds
result["sounds"] = {}
for sound in device.config.sounds:
result["sounds"][sound.name] = sound.path
# hotwords
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
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
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 get_devices():
user = get_user()
devices = DEVICES.get_devices_by_mail(user.mail)
return devices