def auth_return(request):
print(request.GET)
if not xsrfutil.validate_token(settings.SECRET_KEY,
request.GET['state'].encode('UTF-8'),
request.user):
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.GET)
http = httplib2.Http()
http = credential.authorize(http)
service = build("gmail", "v1", http=http)
try:
label_object = {
'messageListVisibility': "show",
'name': "IFP",
'labelListVisibility': "labelShow"
}
label = service.users().labels().create(userId='me',
body=label_object).execute()
print(label['id'])
except errors.HttpError:
print('An error occurred')
storage = DjangoORMStorage(CredentialsModel, 'id', request.user,
'credential')
storage.put(credential)
return HttpResponseRedirect("/")
def form_valid(self, form):
fname = form.cleaned_data['video'].temporary_file_path()
storage = DjangoORMStorage(GoogleAPIOauthInfo, 'id',
self.request.user.id, 'credentials')
credentials = storage.get()
client = build('youtube', 'v3', credentials=credentials)
body = {
'snippet': {
'title': 'My Django Youtube Video',
'description': 'My Django Youtube Video Description',
'tags': 'django,howto,video,api',
'categoryId': '27'
},
'status': {
'privacyStatus': 'unlisted'
}
}
with tempfile.NamedTemporaryFile('wb', suffix='yt-django') as tmpfile:
with open(fname, 'rb') as fileobj:
tmpfile.write(fileobj.read())
insert_request = client.videos().insert(
part=','.join(body.keys()),
body=body,
media_body=MediaFileUpload(tmpfile.name,
chunksize=-1,
resumable=True))
insert_request.execute()
return HttpResponse('It worked!')
def index(request):
"""
Step 1 of Google OAuth 2.0 flow.
"""
# Create and store the per-user flow object
FLOW = flow_from_clientsecrets(
settings.GOOGLE_OAUTH2_CLIENT_SECRET_FILEPATH,
scope=request.session.get('gauth_scope', ''),
redirect_uri=request.build_absolute_uri(reverse('gauth_callback')))
FLOW.params['access_type'] = 'offline'
FLOW.params['approval_prompt'] = 'force' # Properly gets refresh token
FLOW.params['include_granted_scopes'] = 'true' # incremental authorization
FLOW.params['state'] = xsrfutil.generate_token(settings.SECRET_KEY,
request.user)
authorize_url = FLOW.step1_get_authorize_url()
flow_storage = DjangoORMStorage(FlowModel, 'id', request.user, 'flow')
flow_storage.put(FLOW)
# Don't worry if a next parameter is not set. `auth_return` will use the
# homepage by default. Allows for `next_view` to be set from other places.
try:
request.session['next_view'] = request.GET['next']
except KeyError:
pass
return redirect(authorize_url)
def get_user_credentials(client_service, client_id, client_secret):
"""Retrives the clients credentials from storage"""
storage = DjangoORMStorage(Credentials, "id", client_service, "credential")
local_credentials = storage.get(
) # load the user's credentials from storage
if local_credentials:
credentials = OAuth2Credentials(
access_token=local_credentials.access_token,
client_id=client_id,
client_secret=client_secret,
refresh_token=local_credentials.refresh_token,
token_expiry=local_credentials.token_expiry,
token_uri=local_credentials.token_uri,
user_agent=local_credentials.user_agent,
scopes=settings.GOOGLE_OAUTH2_CLIENT['scope'])
try:
if credentials.access_token_expired:
credentials.refresh(httplib2.Http()) # Refresh access token
storage.put(credentials)
return credentials
except AccessTokenRefreshError:
# The access token is stale. Should be storing the refresh tokens?
return None
else:
return None
def auth_return(request):
if not xsrfutil.validate_token(settings.SECRET_KEY, request.GET['state'].encode('UTF-8'), request.user):
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.GET)
storage = DjangoORMStorage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
return HttpResponseRedirect("/")
def home(request):
status = True
if not request.user.is_authenticated:
return HttpResponseRedirect('admin')
storage = DjangoORMStorage(CredentialsModel, 'id', request.user, 'credential')
print(storage)
credential = storage.get()
if credential is None or credential.invalid:
status = False
print('Not Found')
else:
access_token = credential.access_token
http = httplib2.Http()
http = credential.authorize(http)
people_document = "hello world"
service = build('plus', 'v1', http=http)
people_resource = service.people()
people_document = people_resource.get(userId='me').execute()
print(people_document)
#print("hellllllo====", data)
#return HttpResponseRedirect("gmail_authenticate")
return render(request, 'index.html', {'status': status, 'people_document': people_document})
def get(self, request, *args, **kwargs):
storage = DjangoORMStorage(GoogleAPIOauthInfo, 'id', request.user.id,
'credentials')
credentials = storage.get()
global flow
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=request.build_absolute_uri(
reverse(settings.GOOGLE_OAUTH2_CALLBACK_VIEW)))
# TODO: for a downloaded the client_secrets file
'''flow = flow_from_clientsecrets(
settings.GOOGLE_OAUTH2_CLIENT_SECRETS_JSON,
scope='https://www.googleapis.com/auth/youtube',
redirect_uri=request.build_absolute_uri(
reverse(settings.GOOGLE_OAUTH2_CALLBACK_VIEW)))'''
if credentials is None or credentials.invalid:
flow.params['state'] = xsrfutil.generate_token(
settings.SECRET_KEY, request.user)
authorize_url = flow.step1_get_authorize_url()
return redirect(authorize_url)
return redirect('/upload/')
def service(self, request):
storage = DjangoORMStorage(CredentialsModel, 'id', request.user,
'credential')
credential = storage.get()
http = credential.authorize(httplib2.http())
service = build('fusiontables', 'v2', http=http)
return GoogleFusionTableService(service)
def get(self, request, *args, **kwargs):
"""
Defines view that handles redirect information from Google when authorizing access to a given navigator's
Google Calendar
:param request: django request instance object
:rtype: HttpResponse
"""
state_string = request.GET['state']
state_dict = json.loads(
base64.urlsafe_b64decode(state_string).decode('ascii'))
if not xsrfutil.validate_token(settings.SECRET_KEY,
bytes(state_dict['token'], 'utf-8'),
state_dict["nav_id"]):
return HttpResponseBadRequest()
# if not xsrfutil.validate_token(SECRET_KEY, bytes(request.GET['state'], 'utf-8'), search_params["nav_id"]):
# return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.REQUEST)
storage = DjangoORMStorage(
CredentialsModel, 'id',
Navigators.objects.get(id=state_dict["nav_id"]), 'credential')
storage.put(credential)
return HttpResponseRedirect("/v2/calendar_auth/?nav_id={!s}".format(
state_dict["nav_id"]))
def calendar_add_event(request, event_id):
storage = DjangoORMStorage(CredentialsModel, 'user', request.user,
'credential')
credential = storage.get()
if credential is None or credential.invalid == True:
CALENDAR_FLOW.params['state'] = xsrfutil.generate_token(
settings.SECRET_KEY, request.user)
authorize_url = CALENDAR_FLOW.step1_get_authorize_url()
return redirect(authorize_url)
else:
http = httplib2.Http()
http = credential.authorize(http)
event = Event.objects.get(pk=event_id)
calendar_service = build('calendar', 'v3', http=http)
body = {
'start': {
"date": str(event.date)
},
'end': {
"date": str(event.date)
},
'summary': event.summary
}
calendar_request = calendar_service.events().insert(
calendarId='primary',
body=body,
)
response = calendar_request.execute()
return redirect('calendar_eventadded')
def retrieve_credential(self, user_id, authorize=False, scope=[]):
storage = DjangoORMStorage(Staff, 'id', user_id.staff.id, 'credential')
credential = storage.get()
credential = self._check_credential(credential, scope)
if authorize:
credential = self._authorize_credential(credential)
return credential
def get_authenticated_service():
from .models import CredentialsModel
storage = DjangoORMStorage(CredentialsModel, 'id', 1, 'credential')
credentials = storage.get()
client = build('youtube', 'v3', credentials=credentials)
return client
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('/')
def post(self, request):
storage = DjangoORMStorage(CredentialsModel, 'id', request.user,
'credential')
credential = storage.get()
FLOW.params['state'] = xsrfutil.generate_token(settings.SECRET_KEY,
request.user)
authorize_url = FLOW.step1_get_authorize_url()
return HttpResponseRedirect(authorize_url)
def authorize(request):
global credentials
global is_authorize
credentials = flow.step2_exchange(request.GET)
storage = DjangoORMStorage(CredentialsModel,'id',request.user.id,'credentials')
storage.put(credentials)
is_authorize = True
return redirect('generate')
def google_auth_return(request):
if not xsrfutil.validate_token(settings.SECRET_KEY, str(request.GET['state']),
request.user):
return HttpResponseBadRequest('Missing fields in request data')
credential = FLOW.step2_exchange(request.GET)
storage = DjangoORMStorage(UserProfile, 'user', request.user, 'google_credential')
storage.put(credential)
return HttpResponseRedirect("/timetable")
def form_valid(self, form):
fname = form.cleaned_data['video'].temporary_file_path()
storage = DjangoORMStorage(
CredentialsModel, 'id', self.request.user.id, 'credential')
credentials = storage.get()
client = build('youtube', 'v3', credentials=credentials)
body = {
'snippet': {
'title': 'Sample Video Two',
'description': 'Sample Video Two Description',
'tags': 'django,howto,video,api',
'categoryId': '22'
},
'status': {
'privacyStatus': 'public'
}
}
with tempfile.NamedTemporaryFile('wb', suffix='yt-django') as tmpfile:
with open(fname, 'rb') as fileobj:
tmpfile.write(fileobj.read())
insert_request = client.videos().insert(
part=','.join(body.keys()),
body=body,
media_body=MediaFileUpload(
tmpfile.name, chunksize=-1, resumable=True)
)
response = insert_request.execute()
print(response)
video_id = response['id']
channel_id = response['snippet']['channelId']
print(channel_id)
video_url = 'https://www.googleapis.com/youtube/v3/videos'
video_params = {
'part': 'statistics',
'key': settings.GOOGLE_API_KEY,
'id': video_id
}
r = requests.get(video_url, params=video_params)
results = r.json()['items']
print(results)
context = {
'video_id':video_id,
'stats':results
}
video_details = VideoDetails(
video_id = video_id,
channel_id = channel_id
)
video_details.save()
# html = '<html><body><a href="https://www.youtube.com/watch?v={0}">Uploaded Video link</a></body></html>'.format(video_id)
# html = '<html><body><iframe width="1200" height="600" src="https://www.youtube.com/embed/{0}"></iframe></body></html>'.format(video_id)
# return HttpResponse(html)
return render(self.request,'core/uploaded_videos.html',context)
def connect(self, flow, code):
credentials = flow.step2_exchange(code)
storage = DjangoORMStorage(YoutubeProfile, 'user', self.user, 'credentials')
storage.put(credentials)
return True
def get_credentials(self):
# get the storage object
storage = DjangoORMStorage(YoutubeProfile, 'user', self.user, 'credentials')
credentials = storage.get()
logger.info(credentials.invalid)
return credentials
def oauth2_callback(request):
state = request.GET.dict()['state'].encode('UTF-8')
if not xsrfutil.validate_token(settings.SECRET_KEY, state, request.user):
return HttpResponseBadRequest()
flow.redirect_uri = '%s%s' % (request.META['HTTP_REFERER'],'oauth2callback')
credentials = flow.step2_exchange(request.GET.dict()['code'])
storage = DjangoORMStorage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credentials)
# TODO: need to somehow call the sync_sheet view again but need the user and game_id
return HttpResponseRedirect("/")
def get(self, request, *args, **kwargs):
credential = self.retrieve_credential(request.user, authorize=False)
if 'oauth2' in request.path:
credential = self.FLOW.fetch_token(code=request.GET['code'])
credential = self.FLOW.credentials
storage = DjangoORMStorage(Staff, 'id', request.user.staff.id,
'credential')
storage.put(credential)
elif credential is None:
return self.create_google_url()
def get_storage(request): """ Credential storage helper. Args: request: Django request object. Returns: Django storage helper for interacting with the credentials model. """ return DjangoORMStorage(CredentialsModel, 'id', request.user.id, 'credential')
def calendar_auth_return(request):
if not xsrfutil.validate_token(settings.SECRET_KEY,
bytes(request.GET['state'], 'utf-8'),
request.user):
return HttpResponseBadRequest()
credential = CALENDAR_FLOW.step2_exchange(request.GET)
storage = DjangoORMStorage(CredentialsModel, 'user', request.user,
'credential')
storage.put(credential)
return redirect('calendar')
def get(self, request, *args, **kwargs):
storage = DjangoORMStorage(CredentialsModel, 'id', request.user.id,
'credential')
credential = storage.get()
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('/')
def auth_return(request):
get_state = bytes(request.GET.get('state'), 'utf8')
if not xsrfutil.validate_token(settings.SOCIAL_AUTH_GOOGLE_SECRET, get_state,
request.user):
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.GET.get('code'))
storage = DjangoORMStorage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
print("access_token: %s" % credential.access_token)
return HttpResponseRedirect("login/home")
def update_contacts(modeladmin, request, queryset):
storage = DjangoORMStorage(CredentialsModel, 'id', request.user.id, 'credential')
creds = storage.get()
if creds is None or creds.invalid == True:
return redirect('authorize')
service = build('people', 'v1', credentials=creds)
agenda = get_agenda(service)
resultado = []
for p in queryset.all():
if not p.telefone in agenda:
contato = {
"names": [
{
"givenName": p.nome
}
],
"phoneNumbers": [
{
'value': p.telefone
}
],
"emailAddresses": [
{
'value': p.email
}],
"organizations": [
{
"name" : "Teste de importação"
}
],
"userDefined" : [
{
"key" : "obs",
"value": ""
}
]
}
if p.obs:
contato['userDefined'][0]['value'] = p.obs
for o in p.engajamento.all():
contato['organizations'].append({ "name" : o.nome})
c = service.people().createContact(body=contato).execute()
resultado.append(contato)
modeladmin.message_user(request, '{} contatos atualizados.'.format(len(resultado)))
def get(self, request):
get_state = bytes(request.GET.get('state'), 'utf8')
if not xsrfutil.validate_token(settings.SECRET_KEY, get_state,
request.user):
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.GET.get('code'))
storage = DjangoORMStorage(CredentialsModel, 'id', request.user,
'credential')
storage.put(credential)
print("access_token: %s" % credential.access_token)
return HttpResponseRedirect("../admin/hiringapp/submission/")
def get(self, request, *args, **kwargs):
if not xsrfutil.validate_token(settings.SECRET_KEY,
request.GET.get('state').encode(),
request.user):
return HttpResponseBadRequest()
global flow
credentials = flow.step2_exchange(request.GET)
storage = DjangoORMStorage(GoogleAPIOauthInfo, 'id', request.user.id,
'credentials')
storage.put(credentials)
return redirect('/upload/')
def update_user_credential(self):
# Create credential
request = self.request
credential = self.flow.step2_exchange(request.GET)
storage = DjangoORMStorage(CredentialsModel, 'id', request.user,
'credential')
# Write credential
storage.put(credential)
cred, created = CredentialsModel.objects.update_or_create(
id=request.user, credential=credential)
return cred, created
def auth_return(request):
if not xsrfutil.validate_token(settings.SECRET_KEY,
request.REQUEST['state'], request.user):
print request.user
return HttpResponseBadRequest("/")
credential = FLOW.step2_exchange(request.REQUEST)
print credential
storage = DjangoORMStorage(CredentialsModel, 'id', request.user,
'credential')
storage.put(credential)
return HttpResponseRedirect("/")
