Ejemplo n.º 1
0
def auth_request():
    """Authenticate User.

    Returns:
        JSON: JSON data to return to client, whether it be requested data or alerting of lack of authorization.

    """
    if request.method == "GET":
        return
    elif request.method == "OPTIONS":
        # Returns 200 so Chrome's console doesn't spam.
        return jsonify(
            {"message": "OPTIONS requests are ignored by this server!"}), 200
    data = request.get_json()
    try:
        if data["auth"] == "password":
            return auth.get_perma_token(data["user"].lower(), data["password"])
        elif data["auth"] == "perma_token":
            return auth.get_temp_token(data["user"].lower(), data["token"])
        elif data["auth"] == "temp_token":
            r_data = auth.auth_token(data["token"])
            if r_data != {"message": "Authorized"}:
                return jsonify(r_data), 401
            else:
                return
        else:
            return {"message": "Unauthorized!"}, 401
    except KeyError:
        return {"message": "Unauthorized!"}, 401
Ejemplo n.º 2
0
    def get_location(self):
        search = input(f"Hi {self.first}, where would you like to go?\n"
                       ).strip()  # strip all spaces to attach to URL
        if search:
            account_sid = auth.account_sid(
            )  # verify their account_sid to prevent spam
            auth_token = auth.auth_token()  # verify it is them

            client = Client(account_sid,
                            auth_token)  # set up client to authenticate

            phone_number = input(
                "What is your phone number?\n"
            )  # recipient (can be changed to a fixed number)
            from_ = auth.trial()  # sender

            message = client.messages.create(  # create the msg and send!
                to=phone_number,  # input
                from_=from_,  # from auth module
                body=
                f"Here are some locations for {search} https://www.google.com/maps/search/{search.replace(' ', '')}"
            )  # link with location

            print(message)
            print(f"I sent you some location(s) for {search}!")
        else:
            print("You did not enter a location...")  # if input is falsy
Ejemplo n.º 3
0
def document(docid):
    document = app.db.document.find_one({'_id': docid})
    document = doc_mongo_to_app(document)
    if can_read(document, session.get('username')):
        outline = app.db.outline.find({
            'documentid': docid,
            'status': {
                '$ne': 'DELETE'
            }
        })
        outline = list(outline)
        logging.debug("numoutlines %d", len(outline))
        outline = [outline_mongo_to_app(e) for e in outline]
        token = auth.auth_token(session.get('username'), app.secret_key)
        split = urlparse.urlsplit(request.url)
        if split.scheme == "http":
            wsurl = "ws://%s/sub" % split.netloc
        else:
            #hack
            wsurl = "wss://%s:9000/sub" % split.netloc
        return jsonify(document=document,
                       outline=outline,
                       token=token,
                       wsurl=wsurl)
    else:
        return redirect("/login")
Ejemplo n.º 4
0
def document(docid):
    document = app.db.document.find_one({'_id' : docid})
    document = doc_mongo_to_app(document)
    if can_read(document, session.get('username')):
        outline = app.db.outline.find({'documentid': docid,
                                       'status' : {'$ne' : 'DELETE'}})
        outline = list(outline)
        logging.debug("numoutlines %d", len(outline))
        outline = [outline_mongo_to_app(e) for e in outline]
        token = auth.auth_token(session.get('username'), app.secret_key)
        split = urlparse.urlsplit(request.url)
        if split.scheme == "http":
            wsurl = "ws://%s/sub" % split.netloc
        else:
            #hack
            wsurl = "wss://%s:9000/sub" % split.netloc
        return jsonify(document=document,
                       outline=outline,
                       token=token,
                       wsurl=wsurl
                       )
    else:
        return redirect("/login")
Ejemplo n.º 5
0
def callback():
    code = request.args['code']
    token_dict = loads(auth_token(code))
    access_token = token_dict['access_token']
    refresh_token = token_dict['refresh_token']
    print(access_token)
    profile = profile_data(access_token)
    profile_url = profile['href']

    playlist_desc = "List of pop songs from 2002 to 2004"
    playlist_title = "2000s Pop"
    category = "Pop"

    new_playlist = create_playlist(access_token, profile_url, playlist_title, playlist_desc)
    playlist_id = new_playlist['id']
    print(playlist_id)
    urilist = create_urilist(access_token, songs, 2)

    try:
        for song in songs:
            add_to_playlist(access_token, song["name"], song["artist"], 2, playlist_id)
            return "Done"
    except Exception as error:
        print(error)
 def test_some_token(self):
     headers = {"Authorization": "Bearer bla"}
     token = auth.auth_token(headers)
     self.assertEqual(token, "bla")
 def test_too_many_token_parts(self):
     headers = {"Authorization": "Bearer bla bla"}
     with self.assertRaises(Unauthorized) as cm:
         auth.auth_token(headers)
     self.assertEqual(cm.exception.description, "Authorization header must be Bearer + \s + token")
 def test_empty_token(self):
     headers = {"Authorization": "Bearer"}
     with self.assertRaises(Unauthorized) as cm:
         auth.auth_token(headers)
     self.assertEqual(cm.exception.description, "Token not found")
 def test_non_bearer_token(self):
     headers = {"Authorization": "bla"}
     with self.assertRaises(Unauthorized) as cm:
         auth.auth_token(headers)
     self.assertEqual(cm.exception.description, "Authorization header must start with Bearer")
 def test_no_auth_header(self):
     headers = {}
     with self.assertRaises(Unauthorized) as cm:
         auth.auth_token(headers)
     self.assertEqual(cm.exception.description, "Authorization header is expected")
 def test_some_token(self):
     headers = {'Authorization': 'Bearer bla'}
     token = auth.auth_token(headers)
     self.assertEqual(token, 'bla')
 def test_too_many_token_parts(self):
     headers = {'Authorization': 'Bearer bla bla'}
     with self.assertRaises(Unauthorized) as cm:
         auth.auth_token(headers)
     self.assertEqual(cm.exception.description, 'Authorization header must be Bearer + \s + token')
 def test_empty_token(self):
     headers = {'Authorization': 'Bearer'}
     with self.assertRaises(Unauthorized) as cm:
         auth.auth_token(headers)
     self.assertEqual(cm.exception.description, 'Token not found')
 def test_non_bearer_token(self):
     headers = {'Authorization': 'bla'}
     with self.assertRaises(Unauthorized) as cm:
         auth.auth_token(headers)
     self.assertEqual(cm.exception.description, 'Authorization header must start with Bearer')
 def test_no_auth_header(self):
     headers = {}
     with self.assertRaises(Unauthorized) as cm:
         auth.auth_token(headers)
     self.assertEqual(cm.exception.description, 'Authorization header is expected')