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 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 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 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 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 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 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(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 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 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 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 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(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 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_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_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 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 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 gmail_authenticate(request):
messages = []
storage = DjangoORMStorage(CredentialsModel, 'id', request.user,
'credential')
credential = storage.get()
if credential is None or credential.invalid:
FLOW.params['state'] = xsrfutil.generate_token(settings.SECRET_KEY,
request.user)
authorize_url = FLOW.step1_get_authorize_url()
return HttpResponseRedirect(authorize_url)
return filter_messages(request, credential)
class Cred:
SCOPES = 'https://www.googleapis.com/auth/spreadsheets'
CLIENT_SECRET_FILE = settings.GOOGLE_OAUTH2_CLIENT_SECRETS_JSON
APPLICATION_NAME = 'ParseBot-SheetOutput'
REDIRECT_URI = 'http://localhost:8080/oath2callback'
def __init__(self):
self.storage = DjangoORMStorage(CredetialsModel, 'user_id', 1,
'credential')
self.cred = self.storage.get()
self.check_token()
return
def get_cred(self):
return self.cred
def force_refresh(self):
print('refreshing_token...')
requestt = google.auth.transport.requests.Request()
self.cred.refresh(requestt)
self.storage.put(self.cred)
return
def check_token(self):
if self.cred is None:
print('Please Authenticate App with Browser')
return
if self.cred.expired == True:
self.force_refresh()
return
def cred_to_dict(self):
return {
'token': credentials.token,
'refresh_token': self.cred.refresh_token,
'expiry': self.cred.expiry,
'expired': self.cred.expired,
'token_uri': self.cred.token_uri,
'scopes': self.cred.scopes
}
def __str__(self):
dictt = self.cred_to_dict()
return 'Creds {\n' + '\n'.join([
"\t'{}': {},".format(str(item), str(dictt[item])) for item in dictt
]) + '\n}'
def __repr__(self):
dictt = self.cred_to_dict()
return 'Creds {\n' + '\n'.join([
"\t'{}': {},".format(str(item), str(dictt[item])) for item in dictt
]) + '\n}'
def get(self, request, *args, **kwargs):
"""
Defines view that requests authorization for Patient Innovation Center to access a given navigator's Google
calendar
:param request: django request instance object
:rtype: HttpResponse
"""
response_raw_data, rqst_errors = init_v2_response_data()
search_params = validate_get_request_parameters(
request.GET, ["nav_id"], rqst_errors)
if 'nav_id' in search_params:
nav_id = search_params["nav_id"]
try:
picstaff_object = Navigators.objects.get(id=nav_id)
storage = DjangoORMStorage(CredentialsModel, 'id', nav_id,
'credential')
credential = storage.get()
if credential is None or credential.invalid == True:
google_token = xsrfutil.generate_token(
settings.SECRET_KEY, picstaff_object.id)
params_dict = {
"nav_id": nav_id,
"token": google_token.decode('ascii')
}
params_json = json.dumps(params_dict).encode('ascii')
params_base64_encoded = base64.urlsafe_b64encode(
params_json)
authorize_url = FLOW.step1_get_authorize_url(
state=params_base64_encoded)
return HttpResponseRedirect(authorize_url)
else:
response_raw_data["Data"] = "Authorized!"
check_or_create_navigator_google_cal(
credential, rqst_errors)
except Navigators.DoesNotExist:
rqst_errors.append(
'Navigator database entry does not exist for the id: {!s}'.
format(str(nav_id)))
else:
rqst_errors.append("No valid parameters")
response_raw_data["Host"] = settings.HOSTURL
parse_and_log_errors(response_raw_data, rqst_errors)
response = HttpResponse(json.dumps(response_raw_data),
content_type="application/json")
return response
def has_permission(request):
from .models import CredentialsModel
storage = DjangoORMStorage(CredentialsModel, 'id', 1, 'credential')
credential = storage.get()
if credential is None or credential.invalid == True:
flow.params['state'] = xsrfutil.generate_token(settings.SECRET_KEY, 1)
authorize_url = flow.step1_get_authorize_url()
return authorize_url
return True
def get_service(request):
storage = DjangoORMStorage(CredentialsModel, 'id', request.user, 'credential')
credential = storage.get()
if credential is None or credential.invalid:
FLOW.params['state'] = xsrfutil.generate_token(settings.SECRET_KEY, request.user)
authorize_url = FLOW.step1_get_authorize_url()
return HttpResponseRedirect(authorize_url), False
else:
http = httplib2.Http()
http = credential.authorize(http)
service = build("calendar", "v3", http=http)
return service, True
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 add_to_google_calender(request):
site_user = SiteUser.objects.get(user=request.user)
# Get Credentials
storage = Storage(SiteUser, 'user', request.user, 'credential')
credential = storage.get()
# Validate them if invalid then authorize the request again
if credential is None or credential.invalid:
auth_uri = flow.step1_get_authorize_url()
request.session['redirect_url'] = '/add-to-calendar'
return HttpResponseRedirect(auth_uri)
# Get the service
http = httplib2.Http()
http_authorized = credential.authorize(http)
service = build("calendar", "v3", http=http_authorized)
schedule = Schedule.objects.get(sch_id=request.session.pop('sch_id'))
# Event to be added
event = {
'summary':
'Demo Scheduled for Scribe',
'location':
'Skype',
'description':
'To get to know about the service and products of Scribe.',
'start': {
'dateTime': schedule.schedule_date_time.isoformat(),
},
'end': {
'dateTime': (schedule.schedule_date_time +
datetime.timedelta(minutes=30)).isoformat(),
},
'attendees': [
{
'email': schedule.customer.user.email
},
{
'email': schedule.salesman.user.email
},
],
}
# Insert the Event
event = service.events().insert(calendarId='primary', body=event).execute()
schedule.event_link = event.get('htmlLink')
# Redirect to homepage
return HttpResponseRedirect('/home')
def get_mail_service(user):
storage = DjangoORMStorage(models.CredentialsModel, 'id', user,
'credential')
credential = storage.get()
if credential is None or credential.invalid:
FLOW.params['state'] = xsrfutil.generate_token(settings.SECRET_KEY,
user)
authorize_url = FLOW.step1_get_authorize_url()
return HttpResponseRedirect(authorize_url)
service = build('gmail',
'v1',
credentials=credential,
cache_discovery=False)
return service
def notifications(request):
# channel id to find for which salesman it is
channel_id = request.META['HTTP_X_GOOG_CHANNEL_ID']
try:
site_user = SiteUser.objects.get(notification_channel_id=channel_id)
except SiteUser.DoesNotExist:
# As I was trying accounts again and again so I created some channels on which no user is attached
# but google is sending data so ignoring that
return HttpResponse(status=200)
# get credential
storage = Storage(SiteUser, 'user', site_user.user, 'credential')
credential = storage.get()
# Get the service
http = httplib2.Http()
http_authorized = credential.authorize(http)
service = build("calendar", "v3", http=http_authorized)
next_page_token = None
# Get the events of calendar
while True:
event_request = service.events().list(calendarId='primary',
singleEvents=True,
orderBy='startTime',
maxResults=10,
pageToken=next_page_token)
event_results = event_request.execute()
events = event_results.get('items', [])
for event in events:
# Add to database if not exist
try:
event_model = EventFromOtherSources.objects.get(
event_id=event['id'])
except EventFromOtherSources.DoesNotExist:
start_time = parse(event['start']['dateTime'])
end_time = parse(event['end']['dateTime'])
event_model = EventFromOtherSources.objects.create(
event_id=event['id'],
salesman=site_user,
start_time=start_time - start_time.utcoffset(),
end_time=end_time - end_time.utcoffset())
next_page_token = event_results.get('nextPageToken')
# break when data finishes
if next_page_token is None:
break
return HttpResponse(status=200)
def index(request):
storage = DjangoORMStorage(CredentialsModel, 'id', request.user, 'credential')
credential = storage.get()
if credential is None or credential.invalid:
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("calendar", "v3", http=http, cache_discovery=False)
now = datetime.datetime.utcnow().isoformat() + 'Z'
events = service.events().list(calendarId='primary', timeMin=now, maxResults=10, singleEvents=True, orderBy='startTime').execute()
logging.info(events)
return render(request, 'core/welcome.html', {'events': events, })
def home(request):
status = True
if not request.user.is_authenticated:
return HttpResponseRedirect('admin')
storage = DjangoORMStorage(CredentialsModel, 'id', request.user,
'credential')
credential = storage.get()
try:
access_token = credential.access_token
resp, cont = Http().request(
"https://www.googleapis.com/auth/gmail.readonly",
headers={
'Host': 'www.googleapis.com',
'Authorization': access_token
})
print("dfdf", resp, cont)
except:
status = False
print('Not Found')
if request.method == "POST":
form = Upload(request.POST, request.FILES)
if form.is_valid():
print(form.cleaned_data.get("file").name)
print(ContentFile(form.cleaned_data.get("file").read()))
path = default_storage.save(
form.cleaned_data.get("file").name,
ContentFile(form.cleaned_data.get("file").read()))
tmp_file = os.path.join(settings.MEDIA_ROOT, path)
service = build('drive', 'v3', credentials=credential)
# media = MediaFileUpload(path, mimetype='application/pdf')
media = MediaFileUpload(tmp_file, mimetype='image/jpeg')
file = service.files().create(body={
"name":
form.cleaned_data.get("file").name
},
media_body=media,
fields='id').execute()
print(file.get('id'))
else:
form = Upload()
return render(request, 'index.html', {'status': status, "form": form})
def home(request):
context = {}
if request.user.is_authenticated():
logedin = True
else:
logedin = False
context['logedin'] = logedin
activities = Activity.objects.filter(
user=request.user).order_by('event_date')
context['activities'] = activities
context['form'] = ActivityForm()
markers = Activity.objects.all().order_by('-time')
context['markers'] = markers
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("calendar", "v3", http=http)
page_token = None
calendar_list = service.calendarList().list(
pageToken=page_token).execute()
account = calendar_list['items'][0]['summary']
account = account.split('@')
context['account1'] = account[0]
context['account2'] = account[1]
context['user'] = request.user
if not ActivityTag.objects.filter(tag="Study"):
tag1 = ActivityTag(tag="Study")
tag1.save()
if not ActivityTag.objects.filter(tag="Music"):
tag2 = ActivityTag(tag="Music")
tag2.save()
if not ActivityTag.objects.filter(tag="Sports"):
tag3 = ActivityTag(tag="Sports")
tag3.save()
return render(request, 'hypermap/mainpage.html', context)
def get(self, request, *args, **kwargs):
storage = DjangoORMStorage(CredentialsModel, 'id', request.user.id,
'credential')
credential = storage.get()
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/')
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 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 gmail_authenticate(request):
storage = DjangoORMStorage(CredentialsModel, 'id', request.user,
'credential')
credential = storage.get()
if credential is None or credential.invalid:
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('gmail', 'v1', http=http)
print('access_token = ', credential.access_token)
status = True
return render(request, 'index.html', {'status': status})
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 homepage(request):
status = True
if not request.user.is_authenticated:
return render(request=request, template_name="mainapp/homepage.html")
storage = DjangoORMStorage(CredentialsModel, 'id', request.user, 'credential')
credential = storage.get()
try:
access_token = credential.access_token
resp, cont = Http().request("https://www.googleapis.com/auth/gmail.readonly",headers={'Host': 'www.googleapis.com','Authorization': access_token})
except:
status = False
print('gmail access failed')
return render(request=request, template_name="mainapp/homepage.html")
def join_activity(request, activity_id):
try:
this_act = Activity.objects.get(id=activity_id)
except ObjectDoesNotExist:
raise Http404
this_act.joinedBy.add(request.user)
this_act.save()
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("calendar", "v3", http=http)
this_act.calendar_event_id = str(random.randint(1, 9999999999))
this_act.save()
event = {
'id': this_act.calendar_event_id,
'summary': this_act.title,
'location': this_act.address,
'description': this_act.content,
'start': {
'dateTime':
this_act.event_date.isoformat() + "T" +
this_act.event_time.isoformat(),
'timeZone':
'America/New_York',
},
'end': {
'dateTime':
this_act.event_end_date.isoformat() + "T" +
this_act.event_end_time.isoformat(),
'timeZone':
'America/New_York',
},
}
event = service.events().insert(calendarId='primary',
body=event).execute()
return render(request, 'dump.json', content_type='application/json')
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 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}))
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 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}))
