def oauth2callback():
# Specify the state when creating the flow in the callback so that it can
# verified in the authorization server response.
state = flask.session['state']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
flow.redirect_uri = flask.url_for('oauth2callback', _external=True)
# Use the authorization server's response to fetch the OAuth 2.0 tokens.
authorization_response = flask.request.url
flow.fetch_token(authorization_response=authorization_response)
# Store credentials in the session.
# ACTION ITEM: In a production app, you likely want to save these
# credentials in a persistent database instead.
credentials = flow.credentials
flask.session['credentials'] = credentials_to_dict(credentials)
# Load credentials from the session.
credentials = google.oauth2.credentials.Credentials(
**flask.session['credentials'])
# initialize Service
service = googleapiclient.discovery.build(API_SERVICE_NAME,
API_VERSION,
credentials=credentials)
print(flask.session)
return flask.redirect(flask.session['url'])
def authenticate_drive_callback():
# Specify the state when creating the flow in the callback so that it can
# verified in the authorization server response.
state = session['state']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
client_secret_path, scopes=google_scopes, state=state)
flow.redirect_uri = url_for('authenticate_drive_callback', _external=True)
# Use the authorization server's response to fetch the OAuth 2.0 tokens.
authorization_response = request.url
flow.fetch_token(authorization_response=authorization_response)
credentials_query = get_google_credentials()
if credentials_query == None:
# Store credentials
credentials = GoogleCredentials(user_id=current_user.id,
credentials_json=credentials_to_json(
flow.credentials))
db.session.add(credentials)
else:
credentials_query.credentials_json = credentials_to_json(
flow.credentials)
db.session.commit()
return redirect(url_for('settings'))
async def rest_callback(request):
state = request.query['state']
code = request.query['code']
callback_port = request.query['callback_port']
try:
flow = get_flow(f'http://127.0.0.1:{callback_port}/oauth2callback',
state=state)
flow.fetch_token(code=code)
token = google.oauth2.id_token.verify_oauth2_token(
flow.credentials.id_token,
google.auth.transport.requests.Request())
email = token['email']
except Exception as e:
log.exception('fetching and decoding token')
raise web.HTTPUnauthorized() from e
db = request.app['db']
users = [
x async for x in db.select_and_fetchall(
"SELECT * FROM users WHERE email = %s AND state = 'active';",
email)
]
if len(users) != 1:
raise web.HTTPUnauthorized()
user = users[0]
session_id = await create_session(db, user['id'], max_age_secs=None)
return web.json_response({
'token': session_id,
'username': user['username']
})
def oauth2callback():
# Specify the state when creating the flow in the callback so that it can
# verified in the authorization server response.
state = flask.session['state']
try:
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
flow.redirect_uri = flask.url_for('youtube_auth.oauth2callback', _external=True)
# Use the authorization server's response to fetch the OAuth 2.0 tokens.
authorization_response = flask.request.url
flow.fetch_token(authorization_response=authorization_response)
# Store credentials in the session.
# ACTION ITEM: In a production youtube_auth, you likely want to save these
# credentials in a persistent database instead.
credentials = flow.credentials
flask.session['youtube_credentials'] = credentials_to_dict(credentials)
return flask.redirect(flask.url_for('spotify_auth.authorize'))
except Exception as err:
print('something broke: {0}'.format(err) )
return "error"
def auth():
logging.info('Log in by new user')
code = request.args.get('code')
flow.fetch_token(code=code)
credentials = flow.credentials
user = services.get_user_profile(credentials)
user_id = user[u'resourceName']
# Try to select user from database
user = User.get_by_user_id(user_id)
if not user:
user = create_new_user(user_id, credentials)
contact = services.find_contact(credentials)
# Create new contact with name Test Contact
if not contact:
logging.info('Contact not found create new one')
contact = services.create_create(credentials)
user.contact_id = contact[u'resourceName']
# Update refresh token if necessary
if credentials.refresh_token and user.refresh_token != credentials.refresh_token:
logging.info('New refresh token provided')
user.refresh_token = credentials.refresh_token
auth_key = str(uuid4())
user.token = auth_key
user.put()
response = redirect('/')
response.set_cookie(AUTH_KEY, auth_key)
return response
def oauth2callback():
# Specify the state when creating the flow in the callback so that it can
# verified in the authorization server response.
# state = flask.session['state']
url = json.loads(request.data.decode('utf8'))['url']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
CLIENT_SECRETS_FILE, scopes=SCOPES) # , state=state)
flow.redirect_uri = CLIENT_AUTH_REDIRECT_TO
# Use the authorization server's response to fetch the OAuth 2.0 tokens.
authorization_response = url
print('Authorization url is: ' + authorization_response, file=sys.stdout)
flow.fetch_token(authorization_response=authorization_response)
# Store credentials in the session.
# ACTION ITEM: In a production app, you likely want to save these
# credentials in a persistent database instead.
credentials = flow.credentials
flask.session['credentials'] = credentials_to_dict(credentials)
credentials_to_store = credentials_to_dict(credentials, True)
r.hmset(credentials_to_store['token'], credentials_to_store)
return flask.jsonify(credentials_to_store['token'])
def oauth2callback():
# Specify the state when creating the flow in the callback so that it can
# verified in the authorization server response.
state = flask.session['state']
accountname=flask.session['accountname']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
flow.redirect_uri = flask.url_for('gdrive.oauth2callback', _external=True)
# Use the authorization server's response to fetch the OAuth 2.0 tokens.
authorization_response = flask.request.url
flow.fetch_token(authorization_response=authorization_response)
# Store credentials in the session.
# ACTION ITEM: In a production app, you likely want to save these
# credentials in a persistent database instead.
credentials = flow.credentials
idinfo = id_token.verify_oauth2_token(credentials.id_token, requests.Request(), credentials.client_id)
accountname1 = idinfo['email']
if(accountname!=accountname1):
raise TypeError("The account authorized is not equal to the account asked for")
flask.session['credentials.'+accountname] = credentials_to_dict(credentials)
return flask.redirect(flask.url_for('gdrive.bucketinfo', accountname=base64.b64encode(accountname.encode('ascii')).decode('ascii')))
def callback():
if request.method == 'GET':
state = session['state']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(constants.CLIENT_SECRETS_FILE, scopes=constants.SCOPES, state=state)
flow.redirect_uri = url_for('callback', _external=True)
# Fetch the OAuth 2.0 tokens.
authorization_response = request.url
flow.fetch_token(authorization_response=authorization_response)
# Store credentials in the session.
credentials = flow.credentials
session['credentials'] = {
'token': credentials.token,
'refresh_token': credentials.refresh_token,
'token_uri': credentials.token_uri,
'client_id': credentials.client_id,
'client_secret': credentials.client_secret,
'scopes': credentials.scopes
}
session['jwt'] = credentials.id_token
return redirect(url_for('profile'))
else:
return make_response(json.dumps({"Error": "Method not allowed"}), 405,
{"Content-Type": constants.json_type})
def auth():
"""
Returns:
"""
# Specify the state when creating the flow in the callback so that it can
# verified in the authorization server response.
state = flask.session['state']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
CLIENT_SECRETS_FILE, scopes=None, state=state)
flow.redirect_uri = flask.url_for('google_auth.auth', _external=True)
# Use the authorization server's response to fetch the OAuth 2.0 tokens.
authorization_response = flask.request.url
flow.fetch_token(authorization_response=authorization_response)
# Store credentials in the session.
# ACTION ITEM: In a production app, you likely want to save these
# credentials in a persistent database instead.
credentials = flow.credentials
flask.session['credentials'] = credentials_to_dict(credentials)
# return flask.redirect(flask.url_for('a_collect_gmail.collect_mail'))
return flask.redirect('/loading_page')
def redirect():
flow.fetch_token(authorization_response=flask.request.url)
result = {
'access_token': flow.credentials.token,
'refresh_token': flow.credentials.refresh_token,
}
return result
def Melo(request):
if request.user.is_authenticated:
estado = request.GET.get("state")
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
'playlist/client_secrets.json',
scopes=['https://www.googleapis.com/auth/youtube'],
state=estado)
#flow.redirect_uri = 'http://127.0.0.1:8000'+reverse('melo') #LOCAL
flow.redirect_uri = 'https://eplayt.com' + reverse('melo') #REMOTO
authorization_response = request.path
flow.fetch_token(authorization_response=authorization_response +
'?state=' + str(request.GET.get("state")) + '&code=' +
str(request.GET.get("code")) +
'&scope=https://www.googleapis.com/auth/youtube')
# Store the credentials in the session.
# ACTION ITEM for developers:
# Store user's access and refresh tokens in your data store if
# incorporating this code into your real app.
credentials = flow.credentials
request.session['credentials'] = {
'token': credentials.token,
'refresh_token': credentials.refresh_token,
'token_uri': credentials.token_uri,
'client_id': credentials.client_id,
'client_secret': credentials.client_secret,
'scopes': credentials.scopes
}
#print("jeje, estas son mis credenciales",request.session['credentials'])
return redirect(reverse("listas"))
else:
return redirect('/')
def upload(request):
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
'client_secret.json', scopes=['https://www.googleapis.com/auth/drive'])
flow.redirect_uri = 'http://127.0.0.1:8000/upload'
authorization_response = request.build_absolute_uri()
if "http:" in authorization_response:
authorization_response = "https:" + authorization_response[5:]
flow.fetch_token(authorization_response=authorization_response)
credentials = flow.credentials
request.session['credentials'] = {
'token': credentials.token,
'refresh_token': credentials.refresh_token,
'token_uri': credentials.token_uri,
'client_id': credentials.client_id,
'client_secret': credentials.client_secret,
'scopes': credentials.scopes
}
drive_service = build('drive', 'v3', credentials=credentials)
file_metadata = {
'name': 'saved_editorial.txt', # name change acc to file
'mimeType': '*/*'
}
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
media = MediaFileUpload(
os.path.join(BASE_DIR, 'saved_editorial.txt'), # correct file upload
mimetype='*/*',
resumable=True)
file = drive_service.files().create(body=file_metadata,
media_body=media,
fields='id').execute()
print('File ID: ' + file.get('id'))
return render(request, 'upload.html')
def oauth2callback():
# Specify the state when creating the flow in the callback so that it can
# verified in the authorization server response.
state = flask.session['state']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
tmp_url = flask.url_for('oauth2callback', _external=True)
if "http:" in tmp_url:
tmp_url = "https:" + tmp_url[5:]
flow.redirect_uri = tmp_url
# Use the authorization server's response to fetch the OAuth 2.0 tokens.
tmp_url = flask.request.url
if "http:" in tmp_url:
tmp_url = "https:" + tmp_url[5:]
authorization_response = tmp_url
flow.fetch_token(authorization_response=authorization_response)
# Store credentials in the session.
# ACTION ITEM: In a production app, you likely want to save these
# credentials in a persistent database instead.
credentials = flow.credentials
credentials_to_database(credentials, session["user_id"])
return flask.redirect("/")
def oauth2callback():
# Specify the state when creating the flow in the callback so that it can
# verified in the authorization server response.
if 'state' in session:
state = session['state']
print("STATE: ", session['state'])
flow = google_auth_oauthlib.flow.Flow.from_client_config(
current_app.config.get('CLIENT_CONFIG_DATA'),
scopes=current_app.config.get('SCOPES'),
state=state
)
flow.redirect_uri = url_for('auth.oauth2callback', _external=True)
# Use the authorization server's response to fetch the OAuth 2.0 tokens.
authorization_response = request.url
flow.fetch_token(authorization_response=authorization_response)
# Store credentials in db
credentials = flow.credentials
mongo.db.google_credentials.insert_one(
{
'_id': session['user_id'],
'token': credentials.token,
'refresh_token': credentials.refresh_token,
'token_uri': credentials.token_uri,
'client_id': credentials.client_id,
'client_secret': credentials.client_secret,
'scopes': credentials.scopes,
}
)
return redirect(url_for('main.index'))
def create_event(start_time_str,
summary,
duration,
code,
description=None,
location=None):
creds = None
auth_code = code
flow.fetch_token(code=auth_code)
creds = flow.credentials
# if os.path.exists('token.json'): check locally if user info has already been authenticated
# creds = Credentials.from_authorized_user_file('token.json',SCOPES)
# if not creds or not creds.valid:
# if creds and creds.expired and creds.refresh_token:
# creds.refresh(Request())
# else:
# flow = InstalledAppFlow.from_client_secrets_file(os.path.join(settings.BASE_DIR, 'login\\static\\login\\credentials.json'),SCOPES)
# creds = flow.run_local_server(port=0)
# with open('token.json','w') as token:
# token.write(creds.to_json())
service = build('calendar', 'v3', credentials=creds)
matches = list(datefinder.find_dates(start_time_str))
if len(matches):
start_time = matches[0]
end_time = start_time + timedelta(minutes=int(duration))
event = {
'summary': summary,
'location': location,
'description': description,
'start': {
'dateTime': start_time.strftime("%Y-%m-%dT%H:%M:%S"),
'timeZone': 'US/Eastern',
},
'end': {
'dateTime': end_time.strftime("%Y-%m-%dT%H:%M:%S"),
'timeZone': 'US/Eastern',
},
'reminders': {
'useDefault':
False,
'overrides': [
{
'method': 'email',
'minutes': 24 * 60
},
{
'method': 'popup',
'minutes': 10
},
],
},
}
result = service.events().insert(calendarId='primary',
body=event).execute()
async def rest_callback(request):
state = request.query['state']
code = request.query['code']
callback_port = request.query['callback_port']
try:
flow = get_flow(f'http://127.0.0.1:{callback_port}/oauth2callback',
state=state)
flow.fetch_token(code=code)
token = google.oauth2.id_token.verify_oauth2_token(
flow.credentials.id_token,
google.auth.transport.requests.Request())
email = token['email']
except Exception:
log.exception('fetching and decoding token')
raise web.HTTPUnauthorized()
dbpool = request.app['dbpool']
async with dbpool.acquire() as conn:
async with conn.cursor() as cursor:
await cursor.execute(
"SELECT * FROM users WHERE email = %s AND state = 'active';",
email)
users = await cursor.fetchall()
if len(users) != 1:
raise web.HTTPUnauthorized()
user = users[0]
session_id = await create_session(dbpool, user['id'])
return web.json_response({
'token': session_id,
'username': user['username']
})
def oauth2callback():
# Specify the state when creating the flow in the callback so that it can
# verified in the authorization server response.
state = flask.session['state']
uid = flask.session['uid']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
flow.redirect_uri = flask.url_for('oauth2callback', _external=True)
# Use the authorization server's response to fetch the OAuth 2.0 tokens.
authorization_response = flask.request.url
flow.fetch_token(authorization_response=authorization_response)
# Store credentials in the session.
# ACTION ITEM: In a production app, you likely want to save these
# credentials in a persistent database instead.
credentials = flow.credentials
credentials_dict = credentials_to_dict(credentials)
flask.session['credentials'] = credentials_dict
logging.info(f"Current credentials are {credentials_dict}")
sql_handler.save_token(uid, credentials_dict)
response = flask.jsonify(credentials_dict)
response.status_code = 200
return response
def oauth2callback():
# Specify the state when creating the flow in the callback so that it can
# verified in the authorization server response.
state = flask.session['state']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
flow.redirect_uri = flask.url_for('oauth2callback', _external=True)
# Use the authorization server's response to fetch the OAuth 2.0 tokens.
authorization_response = flask.request.url
flow.fetch_token(authorization_response=authorization_response)
# Store credentials in the session.
# ACTION ITEM: In a production app, you likely want to save these
# credentials in a persistent database instead.
credentials = flow.credentials
flask.session['credentials'] = credentials_to_dict(credentials)
user_id = flask.session['user_id']
set_credentials(user_id, credentials)
line_bot_api.push_message(user_id, TextSendMessage(text="已成功連結Google帳號"))
line_bot_api.push_message(
user_id,
TextSendMessage(
text=
"歡迎使用GC Helper(Beta)\n我可以幫你將活動紀錄在Google日曆上喔!\n\n範例格式:\n6/3聚餐，在一二三餐廳\n2017/6/3下午20:00聚餐\n06.03聚餐，在一二三餐廳\n6月3日聚餐，在一二三餐廳\n六月三日聚餐，在一二三餐廳\n六月三號聚餐，在一二三餐廳\n明天下午20:00聚餐"
))
return "已連結，請返回上一頁"
def callback(state):
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
CLIENT_SECRET, scopes=SCOPES, state=state)
flow.redirect_uri = redirect_url
authorization_response = flask.request.url
flow.fetch_token(authorization_response=authorization_response)
return flow.credentials
def oauth2callback():
# Specify the state when creating the flow in the callback so that it can
# verify the authorization server response.
state = flask.session['state']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
flow.redirect_uri = flask.url_for('oauth2callback', _external=True)
# Use the authorization server's response to fetch the OAuth 2.0 tokens.
authorization_response = flask.request.url
flow.fetch_token(authorization_response=authorization_response)
# Store the credentials in the session.
# ACTION ITEM for developers:
# Store user's access and refresh tokens in your data store if
# incorporating this code into your real app.
credentials = flow.credentials
flask.session['credentials'] = {
'token': credentials.token,
'refresh_token': credentials.refresh_token,
'token_uri': credentials.token_uri,
'client_id': credentials.client_id,
'client_secret': credentials.client_secret,
'scopes': credentials.scopes
}
return flask.redirect(flask.url_for('index'))
def oauth2callback():
# Specify the state when creating the flow in the callback so that it can
# verify the authorization server response.
state = flask.session['state']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
flow.redirect_uri = flask.url_for('oauth2callback', _external=True)
# Use the authorization server's response to fetch the OAuth 2.0 tokens.
authorization_response = flask.request.url
flow.fetch_token(authorization_response=authorization_response)
# Store the credentials in the session.
# ACTION ITEM for developers:
# Store user's access and refresh tokens in your data store if
# incorporating this code into your real app.
credentials = flow.credentials
flask.session['credentials'] = {
'token': credentials.token,
'refresh_token': credentials.refresh_token,
'token_uri': credentials.token_uri,
'client_id': credentials.client_id,
'client_secret': credentials.client_secret,
'scopes': credentials.scopes
}
return flask.redirect(flask.url_for('admin'))
def oauth2_callback():
state = request.args.get('state', None)
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
JSON_FILE, scopes=API_SCOPE, state=state)
flow.redirect_uri = REDIRECT_URI
flow.fetch_token(
authorization_response=request.url.replace('http://', 'https://'))
credentials = flow.credentials
auth = {
'token':
credentials.token,
'refresh_token':
credentials.refresh_token,
'id_token':
credentials.id_token,
'token_uri':
credentials.token_uri,
'client_id':
credentials.client_id,
'client_secret':
credentials.client_secret,
'scopes':
credentials.scopes,
'expiry':
datetime.datetime.strftime(credentials.expiry, '%Y-%m-%d %H:%M:%S')
}
id = str(uuid4())
db[id] = auth
return id
def oauth2_callback():
import google.oauth2.credentials
import google_auth_oauthlib.flow
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
'/%s/client_secret.json' %
os.path.dirname(os.path.abspath(__file__)),
scopes=['profile'])
flow.redirect_uri = url_for('oauth2_callback', _external=True)
authorization_response = request.url
flow.fetch_token(authorization_response=authorization_response)
credentials = flow.credentials
from googleapiclient.discovery import build
people_service = build(serviceName='people',
version='v1',
credentials=credentials)
profile = people_service.people().get(resourceName='people/me',
personFields='names').execute()
resource_name = profile['resourceName']
display_name = [
name for name in profile['names']
if name['metadata']['primary'] is True
][0]['displayName']
user = User.query.filter_by(social_id=resource_name).first()
if not user:
user = User(social_id=resource_name, name=display_name)
with app.app_context():
db.session.add(user)
db.session.commit()
user = User.query.filter_by(social_id=resource_name).first()
login_user(user)
return redirect(url_for('index'))
def oauth2callback():
# Specify the state when creating the flow in the callback so that it can
# verify the authorization server response.
state = flask.session['state']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
flow.redirect_uri = flask.url_for('oauth2callback',
_external=True,
_scheme='https')
# Use the authorization server's response to fetch the OAuth 2.0 tokens.
authorization_response = flask.request.url
authorization_response = authorization_response.replace(
"http://", "https://")
flow.fetch_token(authorization_response=authorization_response)
credentials = flow.credentials
client_refresh = {
'email': client_data["email"],
'token': credentials.token,
'token_uri': credentials.token_uri,
'client_id': credentials.client_id,
'client_secret': credentials.client_secret,
'scopes': credentials.scopes
}
if credentials.refresh_token:
client_refresh["refresh_token"] = credentials.refresh_token
migration.clientUpdate(client_refresh)
return flask.redirect(flask.url_for('index'))
def oauth2callback():
# Specify the state when creating the flow in the callback so that it can
# verified in the authorization server response.
state = flask.session['state']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
tmp_url = flask.url_for('oauth2callback', _external=True)
if "http:" in tmp_url:
tmp_url = "https:" + tmp_url[5:]
flow.redirect_uri = tmp_url
# Use the authorization server's response to fetch the OAuth 2.0 tokens.
tmp_url = flask.request.url
if "http:" in tmp_url:
tmp_url = "https:" + tmp_url[5:]
authorization_response = tmp_url
try:
flow.fetch_token(authorization_response=authorization_response)
except:
return render_template("apology.html", message="Please grant access to the google calendar.")
# Store the credentials in venn.db
credentials = flow.credentials
credentials_to_database(credentials, session["user_id"])
if session.get("next") is None:
return redirect("/")
else:
return redirect(session.get("next"))
def oauth2callback():
# Specify the state when creating the flow in the callback so that it can
# verified in the authorization server response.
state = session['state']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
flow.redirect_uri = url_for('oauth2callback', _external=True)
# Use the authorization server's response to fetch the OAuth 2.0 tokens.
authorization_response = request.url
flow.fetch_token(authorization_response=authorization_response)
# Store credentials in the session.
# TODO: In a production app, you likely want to save these
# credentials in a persistent database instead.
credentials = flow.credentials
print("Credentials are of type: ", type(credentials))
session['credentials'] = credentials_to_dict(credentials)
# #Add new user to database if not there already
# db.session.add(new_user_created)
# db.session.commit()
print(session['credentials'])
#Update database with credentials
# TODO: Encrypt credentials prior to adding to database
return redirect(url_for('test_api_request'))
def oauth2callback():
# Specify the state when creating the flow in the callback so that it can
# verified in the authorization server response.
state = current_user.student_profile.cal_state
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
flow.redirect_uri = url_for('student.oauth2callback', _external=True)
# Use the authorization server's response to fetch the OAuth 2.0 tokens.
authorization_response = flask.request.url
flow.fetch_token(authorization_response=authorization_response)
# Store credentials in database
credentials = flow.credentials
current_user.student_profile.cal_token = credentials.token
current_user.student_profile.cal_refresh_token = credentials.refresh_token
current_user.student_profile.cal_token_uri = credentials.token_uri
current_user.student_profile.cal_client_id = credentials.client_id
current_user.student_profile.cal_client_secret = credentials.client_secret
current_user.student_profile.cal_scopes = credentials.scopes
current_user.student_profile.cal_state = state
db.session.add(current_user)
db.session.commit()
add_pending_events()
return redirect(url_for('student.calendar'))
def oauth2callback():
# Specify the state when creating the flow in the callback so that it can
# verified in the authorization server response.
state = flask.session['state']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
constants.CLIENT_SECRETS_FILE, scopes=constants.SCOPES, state=state)
flow.redirect_uri = flask.url_for('utils_api.oauth2callback',
_external=True)
# Use the authorization server's response to fetch the OAuth 2.0 tokens.
authorization_response = flask.request.url
flow.fetch_token(authorization_response=authorization_response)
# Store credentials in the session.
# ACTION ITEM: In a production app, you likely want to save these
# credentials in a persistent database instead.
credentials = flow.credentials
flask.session['credentials'] = _credentials_to_dict(credentials)
print('new token is {}'.format(credentials.to_json))
constants.ACCESS_TOKEN = str(credentials.to_json)
with open(constants.ACCESS_TOKEN_PATH, 'w') as f:
json.dump(credentials.token, f)
f.flush()
return flask.redirect(flask.url_for('utils_api.test_api_request'))
def get_credentials():
# Retrieve parameters. As request_url is sent as a url, we have to parse it.
# Else the whole request will be sent to another location.
state = request.args.get('state')
request_url = urlparse(request.args.get('url')).geturl()
# Specify the state when creating the flow in the callback so that it can
# verified in the authorization server response.
logger.info("Received request to retrieve user credentials")
logger.debug("With url of: " + request_url)
logger.debug("and redirect address of: " + DRIVE_REDIRECT_URI)
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
DRIVE_CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
flow.redirect_uri = DRIVE_REDIRECT_URI
# Use the authorization server's response to fetch the OAuth 2.0 tokens.
authorization_response = request_url
flow.fetch_token(authorization_response=authorization_response)
# Store credentials in the session.
# TODO: In a production version, id likely want to save these
# credentials in a persistent database instead.
credentials = flow.credentials
session['credentials'] = credentials_to_dict(credentials)
# TODO: encrypt response credentials
return json.dumps({
"status": "200",
"credentials": credentials_to_dict(credentials)
})
def __init__(self):
# TODO вынести эту хуйню из init
# Disable OAuthlib's HTTPS verification when running locally.
# *DO NOT* leave this option enabled in production.
os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'
# Get credentials and create an API client
flow = google_auth_oauthlib.flow.InstalledAppFlow.from_client_secrets_file(
self.YOUTUBE_CLIENT_SECRETS_FILE,
self.YOUTUBE_SCOPES,
redirect_uri='urn:ietf:wg:oauth:2.0:oob'
)
auth_url, _ = flow.authorization_url()
webbrowser.open(auth_url, new=0, autoraise=True) # redirect to url
code = input('Enter the authorization code: ')
flow.fetch_token(code=code)
youtube = googleapiclient.discovery.build(
self.YOUTUBE_SERVICE_NAME,
self.YOUTUBE_API_VERSION,
credentials=flow.credentials
)
self.live_broadcasts = YoutubeLiveBroadcasts(youtube)
self.youtube_live_chat = YoutubeLiveChatMessage(youtube)
def oauth2callback():
# Specify the state when creating the flow in the callback so that it can
# verified in the authorization server response.
state = flask.session['state']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
flow.redirect_uri = flask.url_for('oauth2callback', _external=True)
# Use the authorization server's response to fetch the OAuth 2.0 tokens.
authorization_response = flask.request.url
authorization_response = authorization_response.replace('http', 'https')
flow.fetch_token(authorization_response=authorization_response)
# Store credentials in the session.
# ACTION ITEM: In a production app, you likely want to save these
# credentials in a persistent database instead.
credentials = flow.credentials
flask.session['credentials'] = credentials_to_dict(credentials)
return flask.redirect(flask.url_for('test_api_request'))
def oauth2callback():
state = session['state']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
flow.redirect_uri = url_for('oauth2callback', _external=True)
flow.fetch_token(authorization_response=request.url)
save_credentials(flow.credentials)
return redirect(url_for('static', filename='dashboard.html'))
def oauth2callback():
state = flask.session['state']
flow = get_flow()
flow.redirect_uri = flask.url_for('oauth2callback', _external=True)
authorization_response = flask.request.url
flow.fetch_token(authorization_response=authorization_response)
credentials = flow.credentials
flask.session['credentials'] = credentials_to_dict(credentials)
return flask.redirect(flask.url_for('record_api_tokens'))
def google_callback():
hashid = session["ggl:form"]
del session["ggl:form"]
if hashid != request.args.get("state"):
return script_error("oauth-failed")
form = Form.get_with(hashid=hashid)
flow = google_auth_oauthlib.flow.Flow.from_client_config(
settings.GOOGLE_CLIENT_CONFIG,
state=hashid,
scopes=["https://www.googleapis.com/auth/drive.file"],
)
flow.redirect_uri = url_for("google_callback", _external=True, _scheme="https")
flow.fetch_token(authorization_response=request.url.replace("http://", "https://"))
plugin = Plugin(form_id=form.id, kind=PluginKind.google_sheets)
plugin.access_token = json.dumps(
{
"token": flow.credentials.token,
"refresh_token": flow.credentials.refresh_token,
"token_uri": flow.credentials.token_uri,
"id_token": flow.credentials.id_token,
"client_id": flow.credentials.client_id,
"client_secret": flow.credentials.client_secret,
}
)
spreadsheet_title = (
form.name
if form.name
else f"{settings.SERVICE_NAME} submissions for {form.hashid}"
)[:128]
google_creds = json.loads(plugin.access_token)
credentials = google.oauth2.credentials.Credentials(**google_creds)
spreadsheet_id, worksheet_id = create_google_sheet(
form, spreadsheet_title, credentials
)
plugin.plugin_data = {
"spreadsheet_id": spreadsheet_id,
"worksheet_id": worksheet_id,
}
DB.session.add(plugin)
DB.session.commit()
return script_data({"spreadsheet_id": spreadsheet_id})
def google_nisseoauthcallback(store: OAuthStore):
# Specify the state when creating the flow in the callback so that it can
# verified in the authorization server response.
state = store.get_state()
flow = get_flow(state=state, token_updater=store.set_credentials)
flow.redirect_uri = flask.url_for(
'nisseoauthcallback',
_external=True,
_scheme=get_request_scheme())
# Use the authorization server's response to fetch the OAuth 2.0 tokens.
authorization_response = flask.url_for(
'nisseoauthcallback', _external=True, _scheme=get_request_scheme(), **flask.request.values)
flow.fetch_token(authorization_response=authorization_response)
# Store credentials.
# ACTION ITEM: In a production app, you likely want to save these
# credentials in a persistent database instead.
store.set_credentials(flow.credentials)
return ("OK", 200)
def oauth2callback():
# Specify the state when creating the flow in the callback so that it can
# verified in the authorization server response.
state = session['state']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
flow.redirect_uri = 'http://yourjobtracker.com/oauth2callback'
# Use the authorization server's response to fetch the OAuth 2.0 tokens.
authorization_response = request.url
flow.fetch_token(authorization_response=authorization_response)
# Store credentials in the session.
# ACTION ITEM: In a production app, you likely want to save these
# credentials in a persistent database instead.
credentials = flow.credentials
session['credentials'] = credentials_to_dict(credentials)
return redirect('/dashboard/jobs')
