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 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 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}))