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 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 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 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 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 list_spreadsheets(request):
set_ids_list = request.GET.get('ids')
if set_ids_list is None or len(set_ids_list) == 0:
return HttpResponseBadRequest('No entry sets were specified')
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
credential = storage.get()
if credential is not None:
print 'FOUND CREDENTIALS'
print 'Access token: %s' % (credential.access_token,)
print 'Refresh token: %s' % (credential.refresh_token,)
else:
print 'NO CREDENTIALS'
if credential is None or credential.invalid == True:
FLOW.params['state'] = xsrfutil.generate_token(SECRET_KEY, request.user)
authorize_url = FLOW.step1_get_authorize_url()
return HttpResponseRedirect(authorize_url)
else:
sheets = []
http = credential.authorize(httplib2.Http())
drive_service = build('drive', 'v3', http=http)
page_token = None
while True:
response = drive_service.files().list(q="mimeType='application/vnd.google-apps.spreadsheet'",
spaces='drive',
fields='nextPageToken, files(id, name)',
pageToken=page_token).execute()
for file in response.get('files', []):
sheets.append(file)
page_token = response.get('nextPageToken', None)
if page_token is None:
break;
return render(request, 'haslerentries/admin/export-spreadsheet.html', {
'sheets': sheets,
'set_ids': set_ids_list,
})
def auth_return(request):
if not xsrfutil.validate_token(SECRET_KEY, request.GET.get('state').encode("ascii"), request.user):
return HttpResponseBadRequest('XSRF token could not be validated')
credential = FLOW.step2_exchange(request.GET)
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
return HttpResponseRedirect('/admin/haslerentries/entryset/')
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 get_context_data(self, **kwargs):
"""
TODO: This method is just a test that can be deleted
"""
context = super(ShowGoogleUsers, self).get_context_data(**kwargs)
try:
commenter = Commenter.objects.get(email='*****@*****.**')
gstorage = Storage(GoogleCredentialsModel, 'commenter', commenter, 'credential')
credentials = gstorage.get()
if credentials is None:
context['me'] = "No credentials found!"
else:
http = httplib2.Http()
http = credentials.authorize(http)
SERVICE = build('plus', 'v1', http=http)
google_request = SERVICE.people().get(userId=credentials.id_token['sub'])
result = google_request.execute()
#context['me'] = result
context['me'] = credentials.to_json()
except Commenter.DoesNotExist as e:
context['me'] = "Commenter does not exist"
except AccessTokenRefreshError as e:
context['me'] = "Unable to refresh access token"
return context
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 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 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 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 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_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 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 test_locked_put(self, djangoModel):
entity_mock = mock.Mock(credentials=None)
objects = mock.Mock(get_or_create=mock.Mock(return_value=(entity_mock,
None)))
FakeCredentialsModelMock.objects = objects
storage = Storage(FakeCredentialsModelMock, self.key_name,
self.key_value, self.property_name)
storage.locked_put(self.credentials)
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 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 test_locked_put(self, djangoModel):
entity_mock = mock.Mock(credentials=None)
objects = mock.Mock(
get_or_create=mock.Mock(return_value=(entity_mock, None)))
FakeCredentialsModelMock.objects = objects
storage = Storage(FakeCredentialsModelMock, self.key_name,
self.key_value, self.property_name)
storage.locked_put(self.credentials)
def auth_return(request):
if not xsrfutil.validate_token(settings.SECRET_KEY, request.REQUEST['state'],
request.user):
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.REQUEST)
storage = DjangoORMStorage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
return HttpResponseRedirect("/")
def oauth2redirect(request):
global flow
# It is called after user allows the calender permission
# stores the credentials and redirects to next
credential = flow.step2_exchange(request.GET['code'])
storage = Storage(SiteUser, 'user', request.user, 'credential')
storage.put(credential)
return HttpResponseRedirect(request.session.pop('redirect_url'))
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 config_view (request):
storage = Storage(models.CredentialsModel, 'id', request.user, 'credential')
credential = storage.get()
access_granted = True
drive_uri = flow.step1_get_authorize_url()
if credential is None or credential.invalid == True:
access_granted = False
return render(request, 'config.html', {'oauth_drive_uri':drive_uri,'access_granted':access_granted})
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 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 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 test_youtube_connection(self):
if hasattr(settings, 'STAGING_ENV') and settings.STAGING_ENV:
# skip this test on staging
return
storage = DjangoORMStorage(
Credentials, 'email', settings.PRIMARY_YOUTUBE_ACCOUNT,
'credential')
credential = storage.get()
self.assertIsNotNone(credential)
self.assertFalse(credential.invalid)
def _get_google_credential(request):
token = None
if request.user.is_authenticated:
storage = Storage(TokenStorageModel, 'id', request.user, 'credential')
credential = storage.get()
elif request.session.get('access_token'):
credential = google_client.OAuth2Credentials.from_json(token)
return credential or HttpResponseRedirect(
google_flow.step1_get_authorize_url())
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 _get_google_credential(request):
token = None
if request.user.is_authenticated():
storage = Storage(TokenStorageModel, 'id', request.user, 'credential')
credential = storage.get()
elif request.session.get('access_token'):
credential = google_client.OAuth2Credentials.from_json(token)
return credential or HttpResponseRedirect(
google_flow.step1_get_authorize_url())
def get_authenticated_service():
storage = DjangoORMStorage(
Credentials, 'email', settings.PRIMARY_YOUTUBE_ACCOUNT,
'credential')
credentials = storage.get()
if credentials is None or credentials.invalid:
raise YTAuthError
return build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,
http=credentials.authorize(httplib2.Http()))
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 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 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 export_to_gdocs(request):
qs = Match.objects.all()
outfile_path = os.path.join(settings.DATA_DIR, 'exported_data.csv')
model = qs.model
writer = csv.writer(open(outfile_path, 'w'))
headers = []
for field in model._meta.fields:
headers.append(field.verbose_name)
writer.writerow(headers)
headers = []
for field in model._meta.fields:
headers.append(field.name)
for obj in qs:
row = []
for field in headers:
val = getattr(obj, field)
if callable(val):
val = val()
if type(val) == str:
val = val.encode("utf-8")
row.append(val)
writer.writerow(row)
del writer
storage = DjangoORMStorage(
CredentialsModel, 'id', request.user, 'credential')
credential = storage.get()
if credential is None or credential.invalid is True:
FLOW.params['state'] = xsrfutil.generate_token(settings.SECRET_KEY,
request.user)
authorize_url = FLOW.step1_get_authorize_url()
return HttpResponseRedirect(authorize_url)
else:
outfile_path = os.path.join(settings.DATA_DIR, 'exported_data.csv')
http = httplib2.Http()
http = credential.authorize(http)
print('printing file at ' + outfile_path)
with open(outfile_path, 'r') as csvfile:
spamreader = csv.reader(csvfile, delimiter=' ',
quotechar='|')
for row in spamreader:
print(', '.join(row))
service = build("drive", "v3", http=http)
file_metadata = {
'mimeType': 'application/vnd.google-apps.spreadsheet'
}
media = MediaFileUpload(outfile_path,
mimetype='text/csv',
resumable=True)
uploadfile = service.files().create(body=file_metadata,
media_body=media, fields='webViewLink').execute()
return render(request, 'scoutingapp/exporttogdocs.html', {'urlLink': uploadfile['webViewLink']})
return render(request, 'scoutingapp/exporttogdocs.html')
def test_locked_get_no_entities(self, djangoModel):
entities = []
filter_mock = mock.Mock(return_value=entities)
object_mock = mock.Mock()
object_mock.filter = filter_mock
FakeCredentialsModelMock.objects = object_mock
storage = Storage(FakeCredentialsModelMock, self.key_name,
self.key_value, self.property_name)
credential = storage.locked_get()
self.assertIsNone(credential)
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 test_locked_get_no_entities(self, djangoModel):
entities = []
filter_mock = mock.Mock(return_value=entities)
object_mock = mock.Mock()
object_mock.filter = filter_mock
FakeCredentialsModelMock.objects = object_mock
storage = Storage(FakeCredentialsModelMock, self.key_name,
self.key_value, self.property_name)
credential = storage.locked_get()
self.assertIsNone(credential)
def get(self, request):
if not xsrfutil.validate_token(
settings.SECRET_KEY, str(request.GET['state']),
request.user):
return HttpResponseBadRequest()
flow = get_flow(request)
credential = flow.step2_exchange(code=request.GET['code'])
storage = DjangoORMStorage(
Credentials, 'email', settings.PRIMARY_YOUTUBE_ACCOUNT,
'credential')
storage.put(credential)
return HttpResponseRedirect("/")
def get(self, request):
storage = DjangoORMStorage(
Credentials, 'email', settings.PRIMARY_YOUTUBE_ACCOUNT,
'credential')
credential = storage.get()
if credential is None or credential.invalid:
flow = get_flow(request)
flow.params['state'] = xsrfutil.generate_token(settings.SECRET_KEY,
request.user)
authorize_url = flow.step1_get_authorize_url()
return HttpResponseRedirect(authorize_url)
else:
return HttpResponse("credentials are currently valid")
def test_locked_get_no_set_store(self, djangoModel):
fake_model_with_credentials = FakeCredentialsModelMockNoSet()
entities = [
fake_model_with_credentials
]
filter_mock = mock.Mock(return_value=entities)
object_mock = mock.Mock()
object_mock.filter = filter_mock
FakeCredentialsModelMockNoSet.objects = object_mock
storage = Storage(FakeCredentialsModelMockNoSet, self.key_name,
self.key_value, self.property_name)
credential = storage.locked_get()
self.assertEqual(
credential, fake_model_with_credentials.credentials)
def inner(request, *args, **kwargs):
# Try grabbing credential from storage
storage = DjangoORMStorage(CredentialsModel, 'id',
request.user, 'credential')
credential = storage.get()
# Begin process of getting a new credential
if credential is None or credential.invalid:
request.session['next_view'] = request.path
request.session['gauth_scope'] = scope
return (HttpResponse('Unauthorized', status=401)
if ajax else redirect('gauth_index'))
# Everything went well, call wrapped view and give credential to it
kwargs['credential'] = credential
return func(request, *args, **kwargs)
def test_locked_delete(self, djangoModel):
class FakeEntities(object):
def __init__(self):
self.deleted = False
def delete(self):
self.deleted = True
fake_entities = FakeEntities()
entities = fake_entities
filter_mock = mock.Mock(return_value=entities)
object_mock = mock.Mock()
object_mock.filter = filter_mock
FakeCredentialsModelMock.objects = object_mock
storage = Storage(FakeCredentialsModelMock, self.key_name,
self.key_value, self.property_name)
storage.locked_delete()
self.assertTrue(fake_entities.deleted)
def index(request):
storage = DjangoORMStorage(CredentialsModel, 'id', request.user, '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 HttpResponseRedirect(authorize_url)
else:
http = httplib2.Http()
http = credential.authorize(http)
service = build("plus", "v1", http=http)
activities = service.activities()
activitylist = activities.list(collection='public',
userId='me').execute()
logging.info(activitylist)
return render(request, 'plus/welcome.html', {
'activitylist': activitylist,
})
def auth_return(request):
"""
Step 2 of Google OAuth 2.0 flow.
"""
if 'state' not in request.GET:
return redirect('gauth_index')
if not xsrfutil.validate_token(settings.SECRET_KEY,
str(request.GET['state']),
request.user):
return HttpResponseBadRequest()
FLOW = DjangoORMStorage(FlowModel, 'id', request.user, 'flow').get()
if FLOW is None:
return redirect('gauth_index')
credential = FLOW.step2_exchange(request.GET)
cred_storage = DjangoORMStorage(CredentialsModel, 'id', request.user, 'credential')
cred_storage.put(credential)
return redirect(request.session.get('next_view', '/'))
def week_export (request):
week_id = request.POST.get('week_id')
usd_value = float(request.POST.get('usd_value'))
week_begin = datetime.strptime(timezone.now().strftime("%Y")+':'+week_id+'-0', "%Y:%U-%w")
week_end = datetime.strptime(timezone.now().strftime("%Y")+':'+str(int(week_id)+1)+'-0', "%Y:%U-%w")-timedelta(days=1)
week_begin = week_begin.strftime("%Y-%m-%d")
week_end = week_end.strftime("%Y-%m-%d")
week_bookings = models.Booking.objects.filter(departure__range=[week_begin, week_end])
# Create the HttpResponse object with the appropriate CSV header.
file_path = os.path.join(os.path.dirname(__file__), '..','export', "W%s_%s.csv" % (week_id,week_end))
concepts = models.Concept.objects.all()
currencies = models.Currency.objects.all()
with open(file_path, 'wb') as csvfile:
writer = csv.writer(csvfile, delimiter=',', quotechar='"')
writer.writerow([])
writer.writerow(["","WEEK NUMBER",week_id])
writer.writerow(["","USD VALUE",usd_value])
writer.writerow([])
headers = ["Book_nr","Book_date","Booker_name","Guest_names","Arrival","Departure","Status","Total","Commission","Subtotal",
"","Folio Registro"]
for concept in concepts:
headers.append(concept.name)
headers = headers + ["Subtotal",""]
for currency in currencies:
headers.append(currency.slug.upper())
headers = headers + ["Gran Total", "Por Recibir","","Notas"]
writer.writerow(headers)
for b in week_bookings:
total_mxn = b.total*usd_value
row = [
b.book_nr,
b.book_date,
b.booker_name.encode('utf8'),
b.guest_names.encode('utf8'),
b.arrival,
b.departure,
b.status.encode('utf8'),
b.total,
b.commission,
total_mxn,
"",
b.folio
]
concept_total = 0
for concept in concepts:
service = b.service_set.filter(concept__id=concept.id).first()
if service:
row.append(service.value)
concept_total += service.value
else:
row.append("0")
row = row + [concept_total, ""]
payment_total = 0
for currency in currencies:
payment = b.payment_set.filter(currency__id=currency.id).first()
if payment:
row.append(payment.value)
payment_total += payment.value if payment.currency.slug != 'usd' else payment.value*usd_value
else:
row.append("0")
grand_total = total_mxn+concept_total
row.append(grand_total)
row.append(grand_total - payment_total)
row.append(b.notes)
writer.writerow(row)
file_name = "W%s_%s" % (week_id,week_end)
storage = Storage(models.CredentialsModel, 'id', request.user, 'credential')
credential = storage.get()
if credential is None or credential.invalid == True:
return redirect(reverse('config_view'))
http = httplib2.Http()
http = credential.authorize(http)
service = build("drive", "v3", http=http)
file_metadata = {
'name' : file_name,
'mimeType' : 'application/vnd.google-apps.spreadsheet'
}
media = MediaFileUpload(file_path, mimetype='text/csv', resumable=True)
file = service.files().create(body=file_metadata, media_body=media, fields='id').execute()
return redirect(reverse('week_view', kwargs={'week_id':week_id}))
def config_access (request):
credential = flow.step2_exchange(request.REQUEST.get('code'))
storage = Storage(models.CredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
return redirect(reverse('config_view'))
def add_to_spreadsheet(request):
return_url = '/admin/haslerentries/entryset/' # TODO remember filter
set_ids = request.POST.get('ids').split(',')
sheet_id = request.POST.get('sheet')
if set_ids is None or len(set_ids) == 0:
messages.add_message(request, messages.ERROR, 'No entry sets were specified')
return HttpResponseRedirect(request.path)
if sheet_id is None or len(sheet_id) == 0:
messages.add_message(request, messages.ERROR, 'No sheet ID was specified')
return HttpResponseRedirect(request.path)
summary = EntrySetSummary()
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
credential = storage.get()
if credential is not None:
print 'FOUND CREDENTIALS'
print 'Access token: %s' % (credential.access_token,)
print 'Refresh token: %s' % (credential.refresh_token,)
else:
print 'NO CREDENTIALS'
if credential is None or credential.invalid == True:
FLOW.params['state'] = xsrfutil.generate_token(SECRET_KEY, request.user)
authorize_url = FLOW.step1_get_authorize_url()
return HttpResponseRedirect(authorize_url)
else:
http = credential.authorize(httplib2.Http())
service = build('script', 'v1', http=http)
request_body = {
'function': 'addEntrySets',
'parameters': [
sheet_id,
get_enty_sets_data(set_ids)
],
'devMode': ENTRIES_SCRIPT_DEV_MODE,
}
errorMessage = None
try:
response = service.scripts().run(body=request_body, scriptId=ENTRIES_SCRIPT_ID).execute()
if 'error' in response:
# The API executed, but the script returned an error.
error = response['error']['details'][0]
errorMessage = error['errorMessage']
else:
print response['response'].get('result')
# Here, the function returns an array of strings.
# sheetNames = response['response'].get('result')
# print('Sheet names in spreadsheet:')
# for name in sheetNames:
# print("\t{0}".format(name))
#logging.info(response)
except HttpError, e:
print e.content
raise e
if errorMessage is not None:
print('Script error! Message: {0}'.format(errorMessage))
#return_url = request.path
messages.add_message(request, messages.ERROR, errorMessage)
else:
messages.add_message(request, messages.INFO, 'Exported %s entry sets to spreadsheet' % (len(set_ids),))
return HttpResponseRedirect(return_url)
def post(self, request, *args, **kwargs):
"""
Process the POST data sent via AJAX after user clicks on the sign-in button.
"""
# retrive the one-time Google generated code after user granted permission to the app.
code = request.POST.get("code", None)
print("code:" + code)
#print(request.session['test'])
# Make sure the request session is still intact and hasn't been tempered with.
if not xsrfutil.validate_token(settings.SECRET_KEY, str(request.session['state']), None):
return HttpResponseBadRequest()
# if there is no one-time Google generated code then return
if code is None:
return HttpResponse ("No Code")
# Exchange the one-time Google generated code for an AccessToken and RefreshToken.
# Remember that RefreshToken is only generated once during the initial granting of
# permission by the user.
try:
oauth_flow = flow_from_clientsecrets('blog/client_secrets.json', scope="")
oauth_flow.redirect_uri = 'postmessage'
credentials = oauth_flow.step2_exchange(code)
except FlowExchangeError as e:
return HttpResponse("Failed to upgrade the authorization code. 401 %s" % e)
commenter, created = Commenter.objects.get_or_create(email=credentials.id_token['email'], defaults={'plus_id': credentials.id_token['sub']})
request.session['cid'] = commenter.pk
# retrieve the credentials object from the database based on the user's email
gstorage = Storage(GoogleCredentialsModel, 'commenter', commenter, 'credential')
# if the credentials object does not exist or is invalid then store it
if gstorage.get() is None or credentials.invalid == True:
gstorage.put(credentials)
# if the commenter did not exist before, then save his/her basic profile
if created:
SERVICE = build('plus', 'v1')
http = httplib2.Http()
http = credentials.authorize(http)
google_request = SERVICE.people().get(userId='me')
result = google_request.execute(http=http)
try:
commenter.given_name = result['name']['givenName'] if ('name' in result and 'givenName' in result['name']) else None
commenter.family_name = result['name']['familyName'] if ('name' in result and 'familyName' in result['name']) else None
commenter.display_name = result['displayName'] if 'displayName' in result else None
commenter.is_plus_user = result['isPlusUser'] if 'isPlusUser' in result else None
commenter.gender = result['gender'] if 'gender' in result else None
commenter.image_url = result['image']['url'] if ('image' in result and 'url' in result['image']) else None
commenter.language = result['language'] if 'language' in result else None
commenter.birthday = result['birthday'] if 'birthday' in result else None
commenter.age_range_min = result['ageRange']['min'] if ('ageRange' in result and 'min' in result['ageRange']) else None
commenter.age_range_max = result['ageRange']['max'] if ('ageRange' in result and 'max' in result['ageRange']) else None
commenter.save()
except Commenter.DoesNotExist as e:
print(e)
#return HttpResponse(json.dumps(credentials.to_json()))
return HttpResponse(json.dumps({"commenter_id": commenter.pk}))
