def getAuthURL():
FLAGS = gflags.FLAGS
FLOW = OAuth2WebServerFlow(
client_id="819119360720.apps.googleusercontent.com",
client_secret="1J8iirUI-nEdi1RxkKNfFQHq",
scope="https://www.googleapis.com/auth/calendar.readonly",
user_agent="GCalPy-CN/0.3",
)
FLAGS.auth_local_webserver = False
oauthURL = OAuth2WebServerFlow.step1_get_authorize_url(FLOW, redirect_uri="http://tracker.ics.uci.edu/gcal")
return oauthURL, FLOW
def sync(FLOW, code, email):
http = httplib2.Http()
s2 = OAuth2WebServerFlow.step2_exchange(FLOW, code, http=http)
http = s2.authorize(http)
service = build(
serviceName="calendar", version="v3", http=http, developerKey="AIzaSyCcT484gf2or7lsOzcOnGolRWRg4c_JJGI"
)
calendar = service.calendars().get(calendarId="primary").execute()
fp = None
if "id" in calendar:
fp = open("/data/calendars/" + calendar["id"], "w")
else:
fp = open("/data/calendars/tmp", "w")
events = service.events().list(calendarId="primary").execute()
j = 0
while True:
for event in events["items"]:
j += 1
fp.write(json.dumps(event))
fp.write("\n")
pt = events.get("nextPageToken")
if pt:
events = service.events().list(calendarId="primary", pageToken=pt).execute()
else:
break
print "Wrote", j, "events into ", "/data/calendars/" + calendar["id"]
fp.flush()
# The actual view
from galah.web import app, oauth_enabled
from galah.base.crypto.passcrypt import check_seal, deserialize_seal
from galah.db.models import User
from flask.ext.login import login_user
from galah.web.auth import FlaskUser
from flask import redirect, url_for, flash, request
# Google OAuth2
from oauth2client.client import OAuth2WebServerFlow
# Google OAuth2 flow object to get user's email.
if oauth_enabled:
flow = OAuth2WebServerFlow(
client_id=app.config["GOOGLE_SERVERSIDE_ID"],
client_secret=app.config["GOOGLE_SERVERSIDE_SECRET"],
scope="https://www.googleapis.com/auth/userinfo.email",
redirect_uri=app.config["HOST_URL"] + "/oauth2callback")
@app.route("/login/", methods=["GET", "POST"])
def login():
form = LoginForm()
# If the user's input isn't immediately incorrect (validate_on_submit() will
# not check if the email and password combo is valid, only that it could be
# valid)
if form.validate_on_submit():
# Find the user with the given email
try:
user = FlaskUser(User.objects.get(email=form.email.data))
def twplaylist():
flow = OAuth2WebServerFlow(yt_id, yt_secret, scope)
storage = Storage('credentials.dat')
parser = argparse.ArgumentParser(parents=[tools.argparser])
flags = parser.parse_args()
credentials = tools.run_flow(flow, storage, flags)
if credentials is None or credentials.invalid:
credentials = run(flow, storage)
global http
http = httplib2.Http()
http = credentials.authorize(http)
global youtube
youtube = build('youtube', 'v3', http=http)
global twitter
twitter = tweepy.API(tweepy.OAuthHandler(t_id, t_secret))
user = twitter.get_user(t_user)
last_id = ''
while True:
try:
ytlinks = []
if last_id:
print 'Grabbing ' + str(
t_count
) + ' latest tweets from ' + user.screen_name + ' since ' + str(
last_id)
statuses = twitter.user_timeline(id=t_user,
since_id=int(last_id),
count=t_count)
else:
print 'Grabbing ' + str(
t_count) + ' latest tweets from ' + user.screen_name
statuses = twitter.user_timeline(id=t_user, count=t_count)
if len(statuses) > 0:
last_id = statuses[0].id
for status in statuses:
if (match in status.text.lower()) and (
status.entities.has_key('urls')):
url = status.entities.get('urls')[0].get(
'expanded_url')
ytcomlink = re.findall(ytcomReg, url)
ytbelink = re.findall(ytbeReg, url)
if ytbelink != []: ytlinks += ytbelink
if ytcomlink != []: ytlinks += ytcomlink
print 'Adding ' + str(len(ytlinks)) + ' video(s)'
for video in ytlinks:
insert = youtube.playlistItems().insert(
part="snippet",
body=dict(
snippet=dict(playlistId=playlist,
resourceId=dict(kind="youtube#video",
videoId=video))))
response = insert.execute()
else:
print 'No new tweets since last attempt'
print 'Waiting ' + str(sleep) + ' seconds'
time.sleep(int(sleep))
except Exception, e:
print e
client_id=settings.GOOGLE_OAUTH2_CLIENT_ID,
client_secret=settings.GOOGLE_OAUTH2_CLIENT_SECRET,
scope='https://www.googleapis.com/auth/youtube',
redirect_uri='http://localhost:8000/oauth2callback/')
if credential is None or credential.invalid == True:
flow.params['state'] = xsrfutil.generate_token(
settings.SECRET_KEY, request.user)
authorize_url = flow.step1_get_authorize_url()
return redirect(authorize_url)
return redirect('/')
flow = OAuth2WebServerFlow(
client_id=settings.GOOGLE_OAUTH2_CLIENT_ID,
client_secret=settings.GOOGLE_OAUTH2_CLIENT_SECRET,
scope='https://www.googleapis.com/auth/youtube',
redirect_uri='http://localhost:8000/oauth2callback/')
class OAuth2CallbackView(View):
def get(self, request, *args, **kwargs):
if not xsrfutil.validate_token(settings.SECRET_KEY,
request.GET.get('state').encode(),
request.user):
return HttpResponseBadRequest()
credential = flow.step2_exchange(request.GET)
storage = DjangoORMStorage(CredentialsModel, 'id', request.user.id,
'credential')
storage.put(credential)
return redirect('/')
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from oauth2client.client import OAuth2WebServerFlow, FlowExchangeError
from oauth2client.file import Storage
import os
from config import *
SCOPES = [
'https://www.googleapis.com/auth/calendar',
'https://www.googleapis.com/auth/drive', 'profile'
]
flow = OAuth2WebServerFlow(client_id=GOOGLE_OAUTH_CLIENT_ID,
client_secret=GOOGLE_OAUTH_CLIENT_SECRET,
scope=SCOPES,
redirect_uri=GOOGLE_OAUTH_REDIRECT_URI,
access_type='offline',
prompt='consent')
def get_url():
return flow.step1_get_authorize_url()
def save(usr, code):
try:
credentials = flow.step2_exchange(code)
except FlowExchangeError:
return False
os.chdir(
DATA_SET = "1581923297927862000-1582023297927862000"
# Constants to loop over each day
current_time_ns = int(time.time() * 1e9)
one_day_ns = 86400000000000
ONE_DAY = current_time_ns - one_day_ns
DAY = current_time_ns
TOTAL_STEPS = []
DATE = []
# Redirect URI for installed apps
REDIRECT_URI = 'urn:ietf:wg:oauth:2.0:oob'
#Getting the credetials from Google to authorise my code
#Not using a function because user can allow it once
flow = OAuth2WebServerFlow(CLIENT_ID, CLIENT_SECRET, OAUTH_SCOPE, REDIRECT_URI)
authorize_url = flow.step1_get_authorize_url()
print('Go to the following link in your browser:')
print(authorize_url)
code = input('Enter verification code: ').strip()
credentials = flow.step2_exchange(code)
#Looping over i days
for i in range(7):
DAY = DAY - one_day_ns
NEW_DATA_ID = (DAY, DAY - one_day_ns)
#For the DATA_ID formatting
TEST_ID = ("{}-{}".format(NEW_DATA_ID[0], NEW_DATA_ID[1]))
def retrieve_data():
urlJson=stt.BASE_DIR+"/dataOfTwitter/keys/your-app-2e6b0704e6bf.json"
f = open(urlJson, 'rb')
SIGNED_KEY = f.read()
f.close()
scope = ['https://spreadsheets.google.com/feeds', 'https://docs.google.com/feeds']
#scope = 'https://www.googleapis.com/auth/spreadsheets.readonly'
credentials = ServiceAccountCredentials.from_json_keyfile_name(urlJson, scope)
data = {
'refresh_token' : 'your-token-hul2g2WIN1fEis-qn8PjfIMNpZ2',
'client_id' : 'your-client_id.apps.googleusercontent.com',
'client_secret' : 'Cliente-secret-h4Mzbb4RZSZG',
'grant_type' : 'refresh_token',
}
r = requests.post('https://accounts.google.com/o/oauth2/token', data = data)
credentials.access_token = ast.literal_eval(r.text)['access_token']
gc = gspread.authorize(credentials)
return gc
CLIENT_ID = '578335401812itj.apps.googleusercontent.com'
CLIENT_SECRET = 'GghbKvIsnXw_h4M'
flow = OAuth2WebServerFlow(client_id=CLIENT_ID,
client_secret=CLIENT_SECRET,
scope='https://spreadsheets.google.com/feeds https://docs.google.com/feeds',
redirect_uri='http://example.com/auth_return')
import gflags
import httplib2
from apiclient.discovery import build
from oauth2client.file import Storage
from oauth2client.client import OAuth2WebServerFlow
from oauth2client.tools import run
import ConfigParser
config = ConfigParser.ConfigParser()
config.read(['config.ini.dist', 'config.ini'])
FLAGS = gflags.FLAGS
FLOW = OAuth2WebServerFlow(client_id=config.get('google', 'client_id'),
client_secret=config.get('google', 'client_secret'),
scope=config.get('google', 'scope'),
user_agent='Endomondo Sync/0.1')
# To disable the local server feature, uncomment the following line:
# FLAGS.auth_local_webserver = False
# If the Credentials don't exist or are invalid, run through the native client
# flow. The Storage object will ensure that if successful the good
# Credentials will get written back to a file.
storage = Storage('calendar.dat')
credentials = storage.get()
if credentials is None or credentials.invalid == True:
credentials = run(FLOW, storage)
# Create an httplib2.Http object to handle our HTTP requests and authorize it
# with our good Credentials.
pickle.dump(google_credentials, file)
return True
else:
print(GOOGLE_PREFIX + 'Failed to refresh tokens, credentials are invalid now')
return False
if os.path.exists(CREDENTIALS_FILE):
with open(CREDENTIALS_FILE, 'rb') as file:
google_credentials = pickle.load(file)
if not google_refresh_tokens():
flow = OAuth2WebServerFlow(client_id=google_id,
client_secret=google_secret,
scope='https://www.googleapis.com/auth/spreadsheets',
redirect_uri=google_redirect,
prompt='consent')
google_auth_uri = flow.step1_get_authorize_url()
print("Please authorise yourself at the below URL and paste the code here")
print(google_auth_uri)
google_auth_code = input('Code: ')
google_credentials = flow.step2_exchange(google_auth_code)
# Pickle the credentials object
with open(CREDENTIALS_FILE, 'wb') as file:
pickle.dump(google_credentials, file)
##### Set up the Google Sheets service #################################################################################
def ia_credentials_helper(client_id,
client_secret,
credentials_cache_file="credentials.json",
cache_key="default"):
"""Helper function to manage a credentials cache during testing.
This function attempts to load and refresh a credentials object from a
json cache file, using the cache_key and client_id as a lookup.
If this isn't found then it starts an OAuth2 authentication flow, using
the client_id and client_secret and if successful, saves those to the local
cache. See :ref:`helper`.
Args:
client_id (str): Google Drive API client id string for an installed app
client_secret (str): The corresponding client secret.
credentials_cache_file (str): Filepath to the json credentials cache file
cache_key (str): Optional string to allow multiple credentials for a client
to be stored in the cache.
Returns:
OAuth2Credentials: A google api credentials object. As described here:
https://developers.google.com/api-client-library/python/guide/aaa_oauth
"""
def _load_credentials(key):
with open(credentials_cache_file, 'r') as inf:
cache = json.load(inf)
cred_json = cache[key]
return OAuth2Credentials.from_json(cred_json)
def _save_credentials(key, credentials):
cache = {}
try:
with open(credentials_cache_file, 'r') as inf:
cache = json.load(inf)
except (IOError, ValueError) as e:
pass
cache[key] = credentials.to_json()
with open(credentials_cache_file, 'w') as ouf:
json.dump(cache, ouf)
credentials_key = "%s/%s/%s" % (client_id, client_secret, cache_key)
try:
credentials = _load_credentials(credentials_key)
if credentials.access_token_expired:
http = httplib2.Http()
credentials.refresh(http)
except (IOError, ValueError, KeyError, AccessTokenRefreshError) as e:
# Check https://developers.google.com/drive/scopes for all available scopes
OAUTH_SCOPE = ('https://www.googleapis.com/auth/drive ' +
'https://spreadsheets.google.com/feeds')
# Redirect URI for installed apps
REDIRECT_URI = 'urn:ietf:wg:oauth:2.0:oob'
# Run through the OAuth flow and retrieve credentials
flow = OAuth2WebServerFlow(client_id,
client_secret,
OAUTH_SCOPE,
redirect_uri=REDIRECT_URI)
authorize_url = flow.step1_get_authorize_url()
print('Go to the following link in your browser:\n' + authorize_url)
code = input('Enter verification code: ').strip()
credentials = flow.step2_exchange(code)
_save_credentials(credentials_key, credentials)
return credentials
# -*- coding: utf-8 -*-
# See: https://developers.google.com/accounts/docs/OAuth2ForDevices
import httplib2
from six.moves import input
from oauth2client.client import OAuth2WebServerFlow
from googleapiclient.discovery import build
CLIENT_ID = "some+client+id"
CLIENT_SECRET = "some+client+secret"
SCOPES = ("https://www.googleapis.com/auth/youtube", )
flow = OAuth2WebServerFlow(CLIENT_ID, CLIENT_SECRET, " ".join(SCOPES))
# Step 1: get user code and verification URL
# https://developers.google.com/accounts/docs/OAuth2ForDevices#obtainingacode
flow_info = flow.step1_get_device_and_user_codes()
print "Enter the following code at %s: %s" % (flow_info.verification_url,
flow_info.user_code)
print "Then press Enter."
input()
# Step 2: get credentials
# https://developers.google.com/accounts/docs/OAuth2ForDevices#obtainingatoken
credentials = flow.step2_exchange(device_flow_info=flow_info)
print "Access token:", credentials.access_token
print "Refresh token:", credentials.refresh_token
# Get YouTube service
# https://developers.google.com/accounts/docs/OAuth2ForDevices#callinganapi
def load_data_from_google_spreadsheet():
"""Shows basic usage of the Sheets API.
Prints values from a sample spreadsheet.
"""
# The file token.json stores the user's access and refresh tokens, and is
# created automatically when the authorization flow completes for the first
# time.
store = file.Storage('token.json')
creds = store.get()
if not creds or creds.invalid:
flow = OAuth2WebServerFlow(client_id=CLIENT_ID,
client_secret=CLIENT_SECRET,
scope=SCOPES)
creds = tools.run_flow(flow, store)
service = build('sheets', 'v4', http=creds.authorize(Http()))
# Call the Sheets API
sheet_metadata = service.spreadsheets().get(spreadsheetId=SPREADSHEET_ID).execute()
sheets = sheet_metadata.get('sheets', '')
ranges = [sheet['properties']['title']+"!"+CELLS_RANGE for sheet in sheets]
all_data = []
all_users = []
for i, sheetinstance in enumerate(sheets):
all_data.append({ "title": sheetinstance['properties']["title"], "rtl": sheetinstance['properties']['rightToLeft']})
request = service.spreadsheets().values().batchGet(spreadsheetId = SPREADSHEET_ID, ranges = ranges)
data = request.execute()
values = data['valueRanges']
for i, sheetinstance in enumerate(sheets):
rows = values[i]['values']
if rows[0] != ["user","image_url","status"]:
print(f'No data found on {sheetinstance["properties"]["title"]}.')
else:
conversation_data = []
sides = {} # initiate dictionary for user names and profile image
for counter, row in enumerate(rows):
if counter == 1:
try:
talker = { 'username': row[0], 'image_url': row[1], 'status':row[2]}
if row[0] not in all_users:
all_users+=[{'username': row[0], 'image_url': row[1], 'status':row[2]}]
except Exception as e:
print(row)
print(i)
print(sys.stderr, f"could not find valid user1 details in row no. 2 of the spreadsheet")
print(e)
sys.exit(1)
elif counter == 2:
try:
chatmate = { 'username': row[0], 'image_url': row[1], 'status':row[2]}
if row[0] not in all_users:
all_users+=[{'username': row[0], 'image_url': row[1], 'status':row[2]}]
except Exception as e:
print(sys.stderr, f"could not find valid user2 details in row no. 3 of the spreadsheet")
print(e)
sys.exit(1)
elif counter > 3:
try:
time = datetime.datetime.strptime(str(row[2]),"%H:%M")
except Exception as e:
print (sys.stderr, f"illegal time was given on row[{counter}]: {row}")
print(e)
sys.exit(1)
if row[0] in [talker["username"], chatmate["username"]]:
user = row[0]
else:
print(row[0]+" was entered as a username, but is not included in the users list")
print(row)
print("talker: ", talker)
print("chatmate: ", chatmate)
sys.exit(1)
if not(row[1] == ''):
message = row[1]
else:
print(f"Illegal empty message string appears on {time}")
sys.exit(1)
conversation_data.append({"user":user, "message":message, "time": time})
all_data[i]["thread"] = conversation_data
all_data[i]["sides"] = {"talker": talker, "chatmate":chatmate}
all_data[i]["talker"] = talker
all_data[i]["chatmate"] = chatmate
for i in range(0, len(all_data)):
if "talker" in all_data[i] and "chatmate" in all_data[i]:
all_data[i]["other_users"] = [user for user in all_users if (user["username"] != all_data[i]["talker"]["username"] and user["username"] != all_data[i]["chatmate"]["username"])]
return(all_data)
from oauth2client.file import Storage
from oauth2client.client import OAuth2WebServerFlow
from oauth2client.tools import run
import json
FLAGS = gflags.FLAGS
# Set up a Flow object to be used if we need to authenticate. This
# sample uses OAuth 2.0, and we set up the OAuth2WebServerFlow with
# the information it needs to authenticate. Note that it is called
# the Web Server Flow, but it can also handle the flow for native
# applications
# The client_id and client_secret can be found in Google Developers Console
FLOW = OAuth2WebServerFlow(
client_id='317796910577.apps.googleusercontent.com',
client_secret='IvKDHSorjkShs8YHxZtya5-U',
scope='https://www.googleapis.com/auth/calendar.readonly',
user_agent='YOUR_APPLICATION_NAME/YOUR_APPLICATION_VERSION')
# To disable the local server feature, uncomment the following line:
# FLAGS.auth_local_webserver = False
# If the Credentials don't exist or are invalid, run through the native client
# flow. The Storage object will ensure that if successful the good
# Credentials will get written back to a file.
storage = Storage('calendar.dat')
credentials = storage.get()
if credentials is None or credentials.invalid == True:
credentials = run(FLOW, storage)
# Create an httplib2.Http object to handle our HTTP requests and authorize it
CLIENT_SECRET = ''
OAUTH_SCOPE = 'https://www.googleapis.com/auth/drive'
# Redirect URI for installed apps
REDIRECT_URI = 'urn:ietf:wg:oauth:2.0:oob'
#Dropbox account authentication
flow = dropbox.client.DropboxOAuth2FlowNoRedirect(app_key, app_secret)
client = dropbox.client.DropboxClient('')
#print 'linked account: ', client.account_info()
#Run through the OAuth flow and retrieve credentials
flow = OAuth2WebServerFlow(CLIENT_ID,
CLIENT_SECRET,
OAUTH_SCOPE,
redirect_uri=REDIRECT_URI)
authorize_url = flow.step1_get_authorize_url()
print 'Go to the following link in your browser: ' + authorize_url
code = raw_input('Enter verification code: ').strip()
credentials = flow.step2_exchange(code)
# Create an httplib2.Http object and authorize it with our credentials
http = httplib2.Http()
http = credentials.authorize(http)
drive_service = build('drive', 'v2', http=http)
print 'Select and option:'
def oauth_callback(request):
protocol = request.META.get('wsgi.url_scheme', 'https')
domain = request.META['HTTP_HOST'] # 'glasscloor.com'
url_path = request.get_full_path() # '/engagement_path/ref?queries=..'
full_url = '{}://{}{}'.format(protocol, domain, url_path)
queryless_url = full_url[:full_url.find('?')]
# Errors might not necessarily indicate failure.
if request.GET.get('error', None) is not None:
logger.warn('[ ! ] OAuth request returned with an error:'
'\n {}'.format(full_url))
oauth_engagement = get_oauth_engagement_by_url(queryless_url)
if oauth_engagement is None:
logger.warn('[ ! ] OAuth request does not match any OAuthConsumer:'
'\n {}'.format(queryless_url))
engagement = None
target = None
else:
oauth_consumer = oauth_engagement.oauth_consumer
engagement = oauth_engagement.engagement_ptr
# Can't put `ref` in the redirect URI -- have to use `state`.
# Reference: http://stackoverflow.com/a/7722099
ref = request.GET['state']
target_id = Target.decrypt_id(engagement.url_key, ref)
target = Target.objects.get(id=target_id)
access_code = request.GET.get('code', None)
# Missing an access token indicates authorization denial.
if access_code is None:
return HttpResponseRedirect(oauth_consumer.bounce_url)
scope = oauth_consumer.scope.split('+')
if 'email' not in scope:
scope.append('email')
flow = OAuth2WebServerFlow(client_id=oauth_consumer.client_id,
client_secret=oauth_consumer.client_secret,
scope=scope,
redirect_uri=oauth_consumer.callback_url,
access_type='offline',
prompt='consent')
credentials = flow.step2_exchange(access_code)
email = credentials.id_token.get('email', None)
if email is None:
email = 'EMAIL_NOT_PROVIDED'
oauth_result = OAuthResult(timestamp=dj_tz.now(),
userAgent=request.META['HTTP_USER_AGENT'],
ip=request.META['REMOTE_ADDR'],
oauth_engagement=oauth_engagement,
target=target,
email=email,
consumer=oauth_consumer,
credentials=credentials)
oauth_result.save()
OAuthResult.objects.filter(oauth_engagement=oauth_engagement,
target__email=target.email,
email=email,
consumer=oauth_consumer).\
exclude(id=oauth_result.id).\
delete()
if not credentials.refresh_token:
logger.info('[ ! ] Access accepted but refresh token not received for'
' OAuthResult #{}'.format(oauth_result.id))
return HttpResponseRedirect(oauth_consumer.bounce_url)
def get(self):
flow = OAuth2WebServerFlow(CLIENT_ID, CLIENT_SECRET, OAUTH_SCOPE,
REDIRECT_URI)
authorize_url = flow.step1_get_authorize_url()
from apiclient.discovery import build
from oauth2client.file import Storage
from oauth2client.client import OAuth2WebServerFlow
from oauth2client import tools
FLAGS = gflags.FLAGS
# Set up a Flow object to be used if we need to authenticate. This
# sample uses OAuth 2.0, and we set up the OAuth2WebServerFlow with
# the information it needs to authenticate. Note that it is called
# the Web Server Flow, but it can also handle the flow for native
# applications
# The client_id and client_secret can be found in Google Developers Console
FLOW = OAuth2WebServerFlow(client_id='your_project_id',
client_secret='your_project_secret',
scope='https://www.googleapis.com/auth/calendar',
user_agent='Voice Task notifications/v1')
# To disable the local server feature, uncomment the following line:
# FLAGS.auth_local_webserver = False
# If the Credentials don't exist or are invalid, run through the native client
# flow. The Storage object will ensure that if successful the good
# Credentials will get written back to a file.
storage = Storage('credentials.dat')
credentials = storage.get()
if credentials is None or credentials.invalid == True:
credentials = tools.run_flow(FLOW, storage)
# Create an httplib2.Http object to handle our HTTP requests and authorize it
# with our good Credentials.
def __init__(self, proxyHost=None, proxyPort=None, proxyUser=None, proxyPassword=None):
self.__http = createHttp(proxyHost, proxyPort, proxyUser, proxyPassword)
self.__oauth = OAuth2WebServerFlow(self.__APP_ID, self.__APP_SECRET, self.__SCOPE,
redirect_uri=self.__REDIRECT_URI)
def reader_callback(request):
ip = request.META.get('HTTP_X_REAL_IP', None) or request.META.get(
'REMOTE_ADDR', "")
domain = Site.objects.get_current().domain
STEP2_URI = "http://%s%s" % (
(domain + '.com') if not domain.endswith('.com') else domain,
reverse('google-reader-callback'),
)
FLOW = OAuth2WebServerFlow(
client_id=settings.GOOGLE_OAUTH2_CLIENTID,
client_secret=settings.GOOGLE_OAUTH2_SECRET,
scope="http://www.google.com/reader/api",
redirect_uri=STEP2_URI,
user_agent='NewsBlur Pro, www.newsblur.com',
)
FLOW.redirect_uri = STEP2_URI
try:
credential = FLOW.step2_exchange(request.REQUEST)
except FlowExchangeError:
logging.info(" ***> [%s] Bad token from Google Reader." %
(request.user, ))
return render_to_response('social/social_connect.xhtml', {
'error':
'There was an error trying to import from Google Reader. Trying again will probably fix the issue.'
},
context_instance=RequestContext(request))
user_token = None
if request.user.is_authenticated():
user_token = OAuthToken.objects.filter(
user=request.user).order_by('-created_date')
if not user_token:
user_uuid = request.COOKIES.get('newsblur_reader_uuid')
if user_uuid:
user_token = OAuthToken.objects.filter(
uuid=user_uuid).order_by('-created_date')
if not user_token:
session = request.session
if session.session_key:
user_token = OAuthToken.objects.filter(
session_id=request.session.session_key).order_by(
'-created_date')
if not user_token:
user_token = OAuthToken.objects.filter(
remote_ip=ip).order_by('-created_date')
if user_token:
user_token = user_token[0]
user_token.credential = base64.b64encode(pickle.dumps(credential))
user_token.session_id = request.session.session_key
user_token.save()
# Fetch imported feeds on next page load
request.session['import_from_google_reader'] = True
logging.user(request, "~BB~FW~SBFinishing Google Reader import - %s" % ip)
if request.user.is_authenticated():
return render_to_response('social/social_connect.xhtml', {},
context_instance=RequestContext(request))
return HttpResponseRedirect(reverse('import-signup'))
def reset_sync(service_provider):
service = get_gcal(service_provider)
if not service:
return service_provider
Reservation.objects.filter(service_provider=service_provider,
isfromgcal=True).delete()
for reservation in Reservation.objects.filter(
service_provider=service_provider).select_for_update():
if service:
try:
service.events().delete(calendarId=service_provider.gcal_id,
eventId=reservation.gcalid).execute()
except:
pass
reservation.gcalid = None
reservation.gcalimported = None
reservation.save()
service_provider.gcal_updated = None
service_provider.save()
return service_provider
FLOW = OAuth2WebServerFlow(client_id=settings.GOOGLE_CLIENT_ID,
client_secret=settings.GOOGLE_CLIENT_SECRET,
scope='https://www.googleapis.com/auth/calendar',
redirect_uri=settings.BASE_URL +
'/myreservations/gcal/callback',
access_type='offline',
approval_prompt='force')
from django.utils.crypto import get_random_string
from django.http import HttpResponseBadRequest
from django.contrib.auth import authenticate, login
import logging
logger = logging.getLogger(__name__)
from oauth2client.client import OAuth2WebServerFlow
flow = OAuth2WebServerFlow(
client_id=settings.CLIENT_ID,
client_secret=settings.CLIENT_SECRET,
scope=settings.DEFAULT_SCOPE,
auth_uri=settings.AUTHORIZATION_URL,
token_uri=settings.ACCESS_TOKEN_URL,
# use reverse_lazy and string_concat because the resolver is not ready when initializing this
redirect_uri=string_concat(settings.REDIRECT_BASE.rstrip('/'), reverse_lazy('accounts:oauth_callback'))
)
"""Flow instance responsible for handling the OAuth2 process
The following settings parameters are required:
* CLIENT_ID: the client id used to authenticate oneself with the OAuth2 provider
* CLIENT_SECRET: the client secret used to authenticate oneself with the OAuth2 provider
* DEFAULT_SCOPE: the scope to ask for during the OAuth2 process
* AUTHORIZATION_URL: the url of the authorization endpoint to redirect to during step 1 of the process
* ACCESS_TOKEN_URL: the url of the token endpoint to which a POST request is made to get the access token
* REDIRECT_BASE: the base URL to which the OAuth2 endpoint must redirect
"""
def get_login_url (self):
self.__flow = OAuth2WebServerFlow(*musicmanager.oauth)
return self.__flow.step1_get_authorize_url()
def __init__(self):
super(GoogleSignIn, self).__init__('google')
self.flow = OAuth2WebServerFlow(client_id=self.consumer_id,client_secret=self.consumer_secret,scope=['https://www.googleapis.com/auth/userinfo.profile','https://www.googleapis.com/auth/youtube'],redirect_uri=YT_REDIRECT,prompt='consent')
self.flow.params['access_type'] = 'offline'
" " + appendingTime) # This will be mic.say
except KeyError, e:
mic.say("Check Calender that you added it correctly")
page_token = events.get('nextPageToken')
if not page_token:
return
# Create a flow object. This object holds the client_id, client_secret, and
# scope. It assists with OAuth 2.0 steps to get user authorization and
# credentials.
flow = OAuth2WebServerFlow(client_id, client_secret, scope)
# Create a Storage object. This object holds the credentials that your
# application needs to authorize access to the user's data. The name of the
# credentials file is provided. If the file does not exist, it is
# created. This object can only hold credentials for a single user, so
# as-written, this script can only handle a single user.
storage = Storage('credentials.dat')
# The get() function returns the credentials for the Storage object. If no
# credentials were found, None is returned.
credentials = storage.get()
# If no credentials are found or the credentials are invalid due to
# expiration, new credentials need to be obtained from the authorization
# server. The oauth2client.tools.run_flow() function attempts to open an
from mycroft.messagebus.message import Message
from mycroft.util.parse import extract_datetime
from datetime import datetime, timedelta
import httplib2
from googleapiclient.discovery import build
from oauth2client.file import Storage
from oauth2client.client import OAuth2WebServerFlow
from oauth2client import tools
#in the raspberry we add __main__.py for the authorization
UTC_TZ = u'+00:00'
FLOW = OAuth2WebServerFlow(
client_id=
'73558912455-smu6u0uha6c2t56n2sigrp76imm2p35j.apps.googleusercontent.com',
client_secret='0X_IKOiJbLIU_E5gN3NefNns',
scope=[
'https://www.googleapis.com/auth/calendar',
'https://www.googleapis.com/auth/contacts.readonly'
],
user_agent='Smart assistant box')
# TODO: Change "Template" to a unique name for your skill
class DeviceReservationSkill(MycroftSkill):
# The constructor of the skill, which calls MycroftSkill's constructor
def __init__(self):
super(DeviceReservationSkill,
self).__init__(name="DeviceReservationSkill")
@property
from oauth2client.client import OAuth2WebServerFlow
# Why my "App isn't verified" ?
# This might returned by google APIs because we are using a high level scope here
# How to fix it ?
# Just hit the continue anyway button because here you are using you own credentials so no one gonna steal your data
# else complete your developer/app profile and submit for review and get verified
# W4RR10R
__OAUTH_SCOPE = ['https://www.googleapis.com/auth/drive']
__REDIRECT_URI = 'urn:ietf:wg:oauth:2.0:oob'
__CLIENT_ID = input("Enter the client id: ")
__CLIENT_SECRET = input("Enter the client secret: ")
flow = OAuth2WebServerFlow(__CLIENT_ID,
__CLIENT_SECRET,
__OAUTH_SCOPE,
redirect_uri=__REDIRECT_URI)
auth_url = flow.step1_get_authorize_url()
print("Open this URL in any browser and get the refersh token: \n" + auth_url)
refresh_token = input("Enter the Refresh token: ")
auth = flow.step2_exchange(refresh_token).to_json()
print(auth)
def __init__(self, CLIENT_ID, CLIENT_SECRET):
self.flow = OAuth2WebServerFlow(CLIENT_ID,
CLIENT_SECRET,
self.OAUTH_SCOPE,
redirect_uri=self.REDIRECT_URI)
self.credentials = None
def do_authentication(hass, hass_config, config):
"""Notify user of actions and authenticate.
Notify user of user_code and verification_url then poll
until we have an access token.
"""
from oauth2client.client import (OAuth2WebServerFlow,
OAuth2DeviceCodeError, FlowExchangeError)
from oauth2client.file import Storage
oauth = OAuth2WebServerFlow(
client_id=config[CONF_CLIENT_ID],
client_secret=config[CONF_CLIENT_SECRET],
scope='https://www.googleapis.com/auth/calendar.readonly',
redirect_uri='Home-Assistant.io',
)
try:
dev_flow = oauth.step1_get_device_and_user_codes()
except OAuth2DeviceCodeError as err:
hass.components.persistent_notification.create(
'Error: {}<br />You will need to restart hass after fixing.'
''.format(err),
title=NOTIFICATION_TITLE,
notification_id=NOTIFICATION_ID)
return False
hass.components.persistent_notification.create(
'In order to authorize Home-Assistant to view your calendars '
'you must visit: <a href="{}" target="_blank">{}</a> and enter '
'code: {}'.format(dev_flow.verification_url, dev_flow.verification_url,
dev_flow.user_code),
title=NOTIFICATION_TITLE,
notification_id=NOTIFICATION_ID)
def step2_exchange(now):
"""Keep trying to validate the user_code until it expires."""
if now >= dt.as_local(dev_flow.user_code_expiry):
hass.components.persistent_notification.create(
'Authentication code expired, please restart '
'Home-Assistant and try again',
title=NOTIFICATION_TITLE,
notification_id=NOTIFICATION_ID)
listener()
try:
credentials = oauth.step2_exchange(device_flow_info=dev_flow)
except FlowExchangeError:
# not ready yet, call again
return
storage = Storage(hass.config.path(TOKEN_FILE))
storage.put(credentials)
do_setup(hass, hass_config, config)
listener()
hass.components.persistent_notification.create(
'We are all setup now. Check {} for calendars that have '
'been found'.format(YAML_DEVICES),
title=NOTIFICATION_TITLE,
notification_id=NOTIFICATION_ID)
listener = track_time_change(hass,
step2_exchange,
second=range(0, 60, dev_flow.interval))
return True
from oauth2client.client import OAuth2WebServerFlow
from oauth2client.file import Storage
DAYS = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
with open('settings.json') as settings_file:
SETTINGS = json.load(settings_file)
storage = Storage('__credentials__')
credentials = storage.get()
if not credentials:
flow = OAuth2WebServerFlow(
client_id=SETTINGS['client_id'],
client_secret=SETTINGS['client_secret'],
scope="https://www.googleapis.com/auth/calendar.readonly",
redirect_uri="urn:ietf:wg:oauth:2.0:oob"
)
auth_uri = flow.step1_get_authorize_url()
print("Please open\n\n{}\n\nand insert the resulting code here.".format(auth_uri))
code = raw_input("Code: ")
credentials = flow.step2_exchange(code)
storage.put(credentials)
http = httplib2.Http()
http = credentials.authorize(http)
start = datetime.datetime(2012, 12, 10, tzinfo=pytz.timezone("Europe/Berlin"))
end = start + datetime.timedelta(weeks=1)
REQUEST = "https://www.googleapis.com/calendar/v3/calendars/{}/events?timeMin={}&timeMax={}".format(
from apiclient.discovery import build
from oauth2client.file import Storage
from oauth2client.client import OAuth2WebServerFlow
from oauth2client.tools import run
FLAGS = gflags.FLAGS
# Set up a Flow object to be used if we need to authenticate. This
# sample uses OAuth 2.0, and we set up the OAuth2WebServerFlow with
# the information it needs to authenticate. Note that it is called
# the Web Server Flow, but it can also handle the flow for native
# applications
# The client_id and client_secret are copied from the API Access tab on
# the Google APIs Console
FLOW = OAuth2WebServerFlow(client_id='264532138515.apps.googleusercontent.com',
client_secret='B5RpwE_3_a1yIiPMOm6kp8n9',
scope='https://www.googleapis.com/auth/calendar',
user_agent='PYMEBookings/2011_1_11')
# To disable the local server feature, uncomment the following line:
# FLAGS.auth_local_webserver = False
# If the Credentials don't exist or are invalid, run through the native client
# flow. The Storage object will ensure that if successful the good
# Credentials will get written back to a file.
storage = Storage('calendar.dat')
credentials = storage.get()
if credentials is None or credentials.invalid == True:
credentials = run(FLOW, storage)
# Create an httplib2.Http object to handle our HTTP requests and authorize it
# with our good Credentials.
EmailLabel)
from .services import build_gmail_service
from .tasks import (send_message, create_draft_email_message,
delete_email_message, update_draft_email_message,
add_and_remove_labels_for_message)
from .utils import (get_attachment_filename_from_url,
get_email_parameter_choices, create_recipients,
render_email_body, replace_cid_in_html,
create_reply_body_header, reindex_email_message)
logger = logging.getLogger(__name__)
FLOW = OAuth2WebServerFlow(
client_id=settings.GA_CLIENT_ID,
client_secret=settings.GA_CLIENT_SECRET,
redirect_uri=settings.GMAIL_CALLBACK_URL,
scope='https://mail.google.com/',
prompt='consent',
access_type='offline',
)
class SetupEmailAuth(LoginRequiredMixin, View):
def get(self, request):
public = request.GET.get('public', 0)
only_new = request.GET.get('only_new', 0)
state = b64encode(
anyjson.serialize({
'token':
generate_token(settings.SECRET_KEY, request.user.pk),
'public':
