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)
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 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 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 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)
def metric(uuid="", name=""): data = request.json print(name, data) with DeviceDatabase(SQL_DEVICES_URI, debug=DEBUG) as device_db: device = device_db.get_device_by_uuid(uuid) if device is None: return device_db.add_metric(name=name, uuid=uuid, data=data)
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 check_auth(api_key): """This function is called to check if a api key is valid.""" with DeviceDatabase(SQL_DEVICES_URI, debug=DEBUG) as device_db: device = device_db.get_device_by_token(api_key) result = True if not device: result = False elif device.expires_at < time.time(): result = False return result
def pair(code, mail_sender): with DeviceDatabase(SQL_DEVICES_URI, debug=DEBUG) as device_db: device = device_db.get_unpaired_by_code(code) if device: user = get_user() if device_db.add_device(uuid=device.uuid, mail=user.mail): device_db.remove_unpaired(device.uuid) msg = Message("Device was paired", recipients=[user.mail]) mail_sender.send(msg) return True return False
def send_mail(uuid=""): data = request.json with DeviceDatabase(SQL_DEVICES_URI, debug=DEBUG) as device_db: user = device_db.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_sender.send(msg)
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)
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 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)
# Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # from flask import Flask from flask_mail import Mail from flask_sslify import SSLify from personal_mycroft_backend.settings import * from personal_mycroft_backend.database.admin import AdminDatabase from personal_mycroft_backend.database.devices import DeviceDatabase ADMINS = AdminDatabase(SQL_ADMINS_URI, debug=DEBUG) DEVICES = DeviceDatabase(SQL_DEVICES_URI, debug=DEBUG) def create_app(): app = Flask(__name__) app.config["SECRET_KEY"] = SECRET_KEY app.config['SECURITY_PASSWORD_SALT'] = SECURITY_PASSWORD_SALT mail = Mail(app) if SSL: sslify = SSLify(app) from personal_mycroft_backend.backend.utils import nice_json from personal_mycroft_backend.backend.decorators import noindex, donation from personal_mycroft_backend.backend.precise import get_precise_routes from personal_mycroft_backend.backend.auth import get_auth_routes
from personal_mycroft_backend.database.devices import DeviceDatabase db = DeviceDatabase() username = "******" code = "XQFTNM" uuid = "cc3524c7-ff52-42b3-af8f-de89249b19c8s" mail = "fakemail2@not_real.com" # add a device to the db if not db.add_device(uuid): # cant commit device to db before pairing, make available for pairing db.add_unpaired_device(uuid, code) if not db.add_device(uuid): # user did not pair yet, perform manual pairing device = db.get_unpaired_by_code(code) if device: db.add_user(mail, username, "password") if db.add_device(uuid=device.uuid, mail=mail): db.remove_unpaired(device.uuid) # Browse the db device = db.get_device_by_uuid(uuid) print(device.name) print(device.last_seen) print(device.created_at) print(device.paired) print(device.uuid) print(device.ips)
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)