Exemple #1
0
 def get_subscriber_voice_url(uuid=""):
     arch = request.args["arch"]
     with DeviceDatabase(SQL_DEVICES_URI, debug=DEBUG) as device_db:
         device = device_db.get_device_by_uuid(uuid)
         if device is not None:
             device.arch = arch
     return nice_json({"link": ""})
 def hello():
     return nice_json({
         "uri": "/",
         "welcome to Personal Mycroft Backend": {
             "author": "JarbasAI"
         }
     })
Exemple #3
0
 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)
Exemple #4
0
    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)
Exemple #5
0
 def subscription_type(uuid=""):
     sub_type = "free"
     with DeviceDatabase(SQL_DEVICES_URI, debug=DEBUG) as device_db:
         device = device_db.get_device_by_uuid(uuid)
         if device is not None:
             sub_type = device.subscription
         subscription = {"@type": sub_type}
     return nice_json(subscription)
Exemple #6
0
 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)
Exemple #7
0
 def code():
     uuid = request.args["state"]
     code = generate_code()
     print(code)
     with DeviceDatabase(SQL_DEVICES_URI, debug=DEBUG) as device_db:
         device_db = DeviceDatabase(SQL_DEVICES_URI, debug=DEBUG)
         device_db.add_unpaired_device(uuid, code)
         result = {"code": code, "uuid": uuid}
     return nice_json(result)
Exemple #8
0
 def location(uuid):
     with DeviceDatabase(SQL_DEVICES_URI, debug=DEBUG) as device_db:
         device = device_db.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]
             device_db.add_ip(uuid, ip)
             new_location = geo_locate(ip)
             device_db.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)
Exemple #9
0
 def pair(code, uuid, name, mail):
     # pair
     result = {"paired": False}
     with DeviceDatabase(SQL_DEVICES_URI, debug=DEBUG) as device_db:
         device = device_db.get_unpaired_by_uuid(uuid)
         if device and device.code == code:
             user = device_db.get_user_by_mail(mail)
             # create user if it doesnt exist
             if not user:
                 device_db.add_user(mail, name, "666")
             if device_db.add_device(uuid, mail=mail):
                 device_db.remove_unpaired(uuid)
                 result = {"paired": True}
     return nice_json(result)
Exemple #10
0
    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)
Exemple #11
0
    def setting(uuid=""):
        with DeviceDatabase(SQL_DEVICES_URI, debug=DEBUG) as device_db:
            device = device_db.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)