Ejemplo n.º 1
0
def verify():
    if 'email' not in session:
        return redirect(url_for('login'))

    useremail = session['email']
    flow = createflow(useremail)
    authorizeURL = authorize(flow)
    codeform = GooglecodeForm()

    if request.method == 'POST':
        if codeform.validate() == False:
            return render_template('verify.html', form=codeform)
        else:
            # get the google code form the from
            google_code = codeform.google_code.data

            # generate the credentials
            credentials = generate_credentials(flow, google_code)

        return redirect(url_for('extract'))

    elif request.method == 'GET':
        return render_template("verify.html",
                               authorizeURL=authorizeURL,
                               form=codeform)
Ejemplo n.º 2
0
def get_friends_helper(request):
    user = authorize(request)
    if not user:
        return {"message":"Not authorized!"}, 401

    user_entry = db.find_one({"username":user})#["friends"]
    return {"friends":user_entry["friends"],"friend_requests":user_entry["friend_requests"]}, 200
Ejemplo n.º 3
0
def _login(
):  # The login button (also called for auto-login if user was logged in last time)
    global username
    global spoofy
    global logged_in
    global playlists

    username_submit.state(["disabled"])
    if logged_in:  # Logged in logging out
        print("logging out")
        username = None
        playlist_list.delete(0, playlist_list.size() - 1)
        playlists = []
        os.remove("lastuser")
        logged_in = False

    else:  # Logged out loggin in
        spoofy = Spotify(auth=authorize(username))
        user_id = spoofy.me()["id"]

        # Get who we are logged in as
        if username != user_id:
            username = user_id
            with open("lastuser", "w") as f:
                f.write(username)

        logged_in = True

    set_login_state()
    username_submit.state(["!disabled"])
Ejemplo n.º 4
0
def handle_query():
    userName = authenticate.authenticate(request)
    if userName is None:
        print 'this request is not authenticated'
        return build_response_not_authenticated(request)
    authorized, error = authorize.authorize(request, userName)
    if not authorized:
        print 'this action is not authorized for %s' % userName
        return build_response_not_authorized(request, error)
    return forward_and_resign(request)
Ejemplo n.º 5
0
def handle_query():
    userName = authenticate.authenticate(request)
    if userName is None:
        print 'this request is not authenticated'
        return build_response_not_authenticated(request)
    authorized, error = authorize.authorize(request,userName)
    if not authorized:
        print 'this action is not authorized for %s' % userName
        return build_response_not_authorized(request, error)
    return forward_and_resign(request)
Ejemplo n.º 6
0
def add_track_helper(request):
    user = authorize(request)
    if not user:
        return {"message": "Not authorized!"}, 401

    body = loads(request.data)
    track_id = body["track_url"]
    try:
        track_id = track_id.split("track/")[1]
    except Exception:
        print("excepted something")
        print(track_id)

    try:
        track = sp.track(track_id)

        entry = {}
        entry["note"] = body["note"]

        entry["title"] = track["name"]
        entry["artist"] = ', '.join(
            [artist["name"] for artist in track["artists"]])
        entry["album"] = track["album"]["name"]
        #entry["release_date"]
        #entry["duration"]
        entry["id"] = track["id"]
        #entry["noteworthy_timestamp"]
        entry["date_added"] = datetime.datetime.utcnow()

        # update friend's list of received songs
        db.update_one(
            {
                "username": body["friend_username"],
                "friends.username": user
            }, {"$push": {
                "friends.$.songsReceived": entry
            }})

        # update user's list of sent songs
        db.update_one(
            {
                "username": user,
                "friends.username": body["friend_username"]
            }, {"$push": {
                "friends.$.songsSent": entry
            }})
        return {"message": "Song added!"}, 200
    except Exception as e:
        print(e)
        return {"message": "Something went wrong"}, 500
def accept_friend_request_helper(request):
    # check access token
    user = authorize(request)
    if not user:
        return {"message": "Not authorized!"}, 401

    body = loads(request.data)
    friend_username = body["friend_username"]

    if not db.find_one({"username": user, "friend_requests": friend_username}):
        return {
            "message": "Friend not found in pending friend requests.  Weird"
        }, 404

    # add accepted friend to user's friend list
    friends = db.find_one({"username": user})["friends"]
    new_friend = {
        "username": friend_username,
        "songsReceived": [],
        "songsSent": []
    }
    friends.append(new_friend)
    db.update_one({"username": user}, {"$set": {"friends": friends}})

    # clear new friend from requests
    db.update_one({"username": user},
                  {"$pull": {
                      "friend_requests": friend_username
                  }})

    # add user to the accepted friend's friend list
    other_friends = db.find_one({"username": friend_username})["friends"]
    other_friends.append({
        "username": user,
        "songsReceived": [],
        "songsSent": []
    })
    db.update_one({"username": friend_username},
                  {"$set": {
                      "friends": other_friends
                  }})

    return {"message": "friend added!"}, 200
Ejemplo n.º 8
0
def main():
	""" Main function """
	parser = make_parser()
	arguments = parser.parse_args(sys.argv[1:])
	arguments = vars(arguments)
	command = arguments.pop('command')

	auth = authorize.authorize()
 	
	if command == 'timeline':
		response = requests.get(TIMELINE_URL, auth=auth)
		print response.json()

	if command == 'friends':
		response = requests.get(FRIENDS_URL, auth=auth)
		#print response.json()
		for c in response.json()['users']:
			print c['name']

	if command == 'followers':
		response = requests.get(FOLLOWERS_URL, auth=auth)
		#print response.json()
		for c in response.json()['users']:
			print c['name']
import os
import pickle
from pprint import pprint as pp
import sys
import xml.dom.minidom
import xmltodict

from goodreads import client

from authorize import authorize

CONSUMER_KEY = os.environ.get('GR_KEY')
CONSUMER_SECRET = os.environ.get('GR_SECRET')
SESSION = 'session' 

try:
    session = pickle.load(open(SESSION, "rb"))
except FileNotFoundError:
    session = authorize()

ACCESS_TOKEN = session.access_token
ACCESS_TOKEN_SECRET = session.access_token_secret

gc = client.GoodreadsClient(CONSUMER_KEY, CONSUMER_SECRET)
gc.authenticate(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)

resp = session.get("/updates/friends.xml")
#xml_out = xml.dom.minidom.parseString(resp.content)
d = xmltodict.parse(resp.content)
pp(d)
Ejemplo n.º 10
0
#-*- coding: utf-8 -*-

import xlrd 
from xlwt import Workbook
import time
#import pytz
import datetime, shutil, os, sys
import authorize

base_dir = ''
if __name__ == '__main__':
    
    authorize.authorize()
    
    #打开excel
    src_fname = base_dir + 'order-item-info.xls'
    if not os.path.exists(src_fname):
        print u"\n\t文件: order-item-info.xls 不存在\n"
        os.system("pause")
        sys.exit(0)
        
    src_excel = xlrd.open_workbook(src_fname) #注意这里的workbook首字母是小写
        
    fname = base_dir + 'amazon/'  + time.strftime(u"%Y-%m-%d %H.%M", time.localtime()) + '.txt'
    track_num_file = open(fname, 'w')

    table = src_excel.sheets()[0]
    lines = [u'order-id\torder-item-id\tquantity\tship-date\tcarrier-code\tcarrier-name\ttracking-number\tship-method\n']
    
    ship_date = (datetime.datetime.now() - datetime.timedelta(hours=15)).strftime('%Y-%m-%d')
    
Ejemplo n.º 11
0
# SunTweet
# This script will tweet about the sun

import time
import twitter
from Sun import *
from authorize import authorize

#Start up a twitter API
api=authorize()

#Create a new data point to monitor
solarDataPoint=datum("/home/andy/Dropbox/Projects/Python/SunTweet/test.txt")

#Update the data point every 15 minutes
lastTime=time.time()
lastSolarTime=solarDataPoint.GetDateTime()
while True:
	currTime=time.time() #Check current time
	if (currTime>=lastTime+15*60):
		solarDataPoint.Update()
		solarTime=solarDataPoint.GetDateTime()
		solarValue=solarDataPoint.GetValue()

		if (solarTime!=lastSolarTime): #Make sure log is being updated
			if (solarValue>10): #Based on the value of the data point, tweet about it
				api.PostUpdate("The sun is currently shining at "+solarValue+" watts")

			lastSolarTime=solarTime
		else:
			print "Log dupe"
Ejemplo n.º 12
0
def test_login_success():
    user_email = "*****@*****.**"
    passwd = "love"
    usr_dict = {'email': user_email, 'password': passwd}
    auth = authorize.authorize(usr_dict, None)
    assert has_token_for(user_email, auth)
Ejemplo n.º 13
0
def test_bad_password():
    user_email = "*****@*****.**"
    passwd = "arghf"
    usr_dict = {'email': user_email, 'password': passwd}
    auth = authorize.authorize(usr_dict, None)
    assert check_by_schema(schema_for_http(403, {"type": "string", "const": "invalid email,hash combo"}), auth)
Ejemplo n.º 14
0
    # Show a more descriptive message if the file doesn't exist.
    if not os.path.exists(path):
        logger.error("Couldn't find an account file at {}.".format(path))
        logger.error("Are you in the right directory? Did you register yet?")
        logger.error("Run 'manuale -h' for instructions.")
        raise ManualeError()

    try:
        with open(path, 'rb') as f:
            return deserialize_account(f.read())
    except (ValueError, IOError) as e:
        logger.error("Couldn't read account file. Aborting.")
        raise ManualeError(e)


account = load_account('account.json')

print(account.key)
# sys.exit()

acme = Acme(LETS_ENCRYPT_PRODUCTION, account)
print(acme.url)

authorize.authorize(LETS_ENCRYPT_PRODUCTION, account, ['quydxtu11.tk'], 'dns')

time.sleep(60)

# rds = redis.StrictRedis(host=REDIS_SERVER, port=REDIS_PORT, db=REDIS_DB)
# authz = rds.hget('xx12', 'authz')
# authorize.verify_auth(account.key, authz)
def main(args):
    API_KEY=au.FLAGS['API_KEY']
    gp_api=a.authorize(API_KEY)