def create_ssp_view(request):
#Aqui cargo los datos del usuario
form = UserNewProject()
status = ""
if request.method == "POST":
if 'create_ssp' in request.POST:
form = UserNewProject(request.POST)
if form.is_valid():
storage = Storage(CredentialsModel, 'id_user', 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:
name_ssp = form.cleaned_data['name_ssp']
description_ssp = form.cleaned_data['description_ssp']
user = User.objects.get(username__exact=request.user.get_username())
projectsUser = userSoftSystemProject.objects.filter(manager=user, name_ssp=name_ssp)
if projectsUser:
status = "0"
form = UserNewProject()
ctx = {'status' : status, 'form' : form}
return render(request,'principal/user_new_ssp.html', ctx)
try:
storage = Storage(CredentialsModel, 'id_user', request.user, 'credential')
credential = storage.get()
http = httplib2.Http()
http = credential.authorize(http)
drive_service = build('drive', 'v2', http=http, developerKey="hbP6_4UJIKe-m74yLd8tQDfT")
except:
return redirect('vista_logout')
newSSP = userSoftSystemProject.objects.create(manager = user, name_ssp = name_ssp, description_ssp = description_ssp)
newStateOne = StateOne.objects.create(ssp_stateOne = newSSP)
newStateTwo = StateTwo.objects.create(ssp_stateTwo = newSSP)
newStateThree = StateThree.objects.create(ssp_stateThree = newSSP)
newSSP.save()
newStateOne.save()
newStateTwo.save()
newStateThree.save()
body = {
'title': '%s'%(newSSP.name_ssp),
'mimeType': "application/vnd.google-apps.folder",
'parents' : [{'id' : user.get_profile().id_drive_folder}]
}
folder = drive_service.files().insert(body = body).execute()
newSSP.id_folder_ssp = folder.get('id')
newSSP.save()
return redirect('vista_principal')
ctx = {'form': form}
return render(request,'principal/user_new_ssp.html', ctx)
def create(request):
storage = Storage(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:
http = httplib2.Http()
http = credential.authorize(http)
service = build(serviceName='calendar', version='v3', http=http)
if request.method == 'POST':
form = CreateForm(request.POST)
if form.is_valid():
calendar = {
'summary': form.cleaned_data['nombre'],
'timeZone': form.cleaned_data['zona_horaria'],
}
created_calendar = service.calendars().insert(body=calendar).execute()
return render(request, 'welcome2.html', {'created_calendar': created_calendar})
else:
form = CreateForm()
return render(request, 'create_calendar.html', {'form': form})
def get_credentials(gmail_account):
"""
Get the credentials for the given EmailAccount, what should be a Gmail account.
If there are no valid credentials for the account, is_authorized is set to
False and there will be an InvalidCredentialsError raised.
Arguments:
gmail_account (instance): EmailAccount instance
Returns:
credentials for the EmailAccount
Raises:
InvalidCredentialsError, if there are no valid credentials for the account.
"""
storage = Storage(GmailCredentialsModel, 'id', gmail_account,
'credentials')
credentials = storage.get()
if credentials is not None and credentials.invalid is False:
return credentials
else:
gmail_account.is_authorized = False
gmail_account.save()
logger.error('no credentials for account %s' % gmail_account)
raise InvalidCredentialsError('no credentials for account %s' %
gmail_account)
def getAllStudentsOrgUnit(user):
#adminUser = User.objects.get(email='*****@*****.**')
storage = Storage(CredentialsModel, 'id', user, 'credential')
credential = storage.get()
if credential is None or credential.invalid == True:
#return HttpResponseRedirect("/login/")
return False
else:
http = httplib2.Http()
http = credential.authorize(http)
directory_service = build("admin", "directory_v1", http=http)
all_users = []
page_token = None
params = {'domain': 'student.alvaradoisd.net', 'fields':'nextPageToken,users(name,id,orgUnitPath,primaryEmail)'}
while True:
try:
if page_token:
params['pageToken'] = page_token
current_page = directory_service.users().list(**params).execute()
all_users.extend(current_page['users'])
page_token = current_page.get('nextPageToken')
if not page_token:
break
except errors.HttpError as error:
return 'An error occurred: %s' % error
break
return all_users
def driveUpload(user, FILENAME):
storage = Storage(CredentialsModel, 'id', user, 'credential')
credential = storage.get()
if credential is None or credential.invalid == True:
#return HttpResponseRedirect("/login/")
return render_to_response('google-login-wait.html', {})
else:
# Path to the file to upload
#FILENAME = filePath
fdir, fname = os.path.split(FILENAME)
http = httplib2.Http()
http = credential.authorize(http)
drive_service = build("drive", "v2", http=http)
# Insert a file
media_body = MediaFileUpload(FILENAME,
mimetype='application/sst',
resumable=True)
body = {
'title': fname,
'description': 'Simple Sheets Worksheet',
'mimeType': 'application/sst'
}
file = drive_service.files().insert(body=body,
media_body=media_body).execute()
return file['id']
def test_gdata_token(request):
"""Tests to make sure credentials are still valid"""
storage = Storage(CredentialsModel, "id", request.user, "credential")
credential = storage.get()
if credential is None or credential.invalid == True:
return JsonResponse({"status": "failed"})
return JsonResponse({"status": "success"})
def _get_user_credentials(self, user):
from orders_manager.models import CredentialsModel
user = user if not hasattr(user, 'user') else user.user
try:
storage = Storage(CredentialsModel, 'id', user, 'credential')
credential = storage.get()
except:
raise ValueError('Credentials for user \'%s\' was not found!' %
user.profile.get_full_name())
if not credential:
raise ValueError('User \'%s\' has no credentials' %
user.profile.get_full_name())
if credential.invalid:
raise ValueError('Credentials are invalid for user \'%s\'!' %
user.profile.get_full_name())
try:
if credential.access_token_expired:
http = credential.authorize(httplib2.Http())
credential.refresh(http)
except Exception as ex:
raise ValueError('Bad user credentials! ' + ex.args[0])
return credential
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 = Storage(CredentialsModel, 'id_user', request.user, 'credential')
storage.delete()
storage = Storage(CredentialsModel, 'id_user', request.user, 'credential')
storage.put(credential)
userP = userProfile.objects.get(user=request.user)
if userP.id_drive_folder is None:
try:
storage = Storage(CredentialsModel, 'id_user', request.user, 'credential')
credential = storage.get()
http = httplib2.Http()
http = credential.authorize(http)
drive_service = build('drive', 'v2', http=http, developerKey="hbP6_4UJIKe-m74yLd8tQDfT")
body = {
'title': 'Soft System Manager',
'mimeType': "application/vnd.google-apps.folder"
}
folder = drive_service.files().insert(body = body).execute()
userP.id_drive_folder = folder.get('id')
userP.save()
except:
return redirect('vista_logout')
return HttpResponseRedirect("/principal")
def auth_gmail(request):
print ("Authenticaion Gmail request")
storage = Storage(CredentialsModel, 'id', request.user.id, 'credential')
credential = storage.get()
print ("credential: %s" % credential)
if credential is None or credential.invalid == True:
print ("call authentication")
FLOW.params['state'] = xsrfutil.generate_token(settings.SECRET_KEY,
request.user)
authorize_url = FLOW.step1_get_authorize_url()
return HttpResponseRedirect(authorize_url)
else:
print ("in the else statement whenre authenticated")
http = httplib2.Http()
http = credential.authorize(http)
service = build("gmail", "v1", http=http)
threads = service.users().threads().list(userId='me').execute()
messages = service.users().messages().list(userId='me', q='reservation confirmation').execute()
#activities = service.activities()
#activitylist = activities.list(collection='public',
# userId='me').execute()
#logging.info(threads)
return render_to_response('app/welcome.html', {
'threads': messages['messages'],
})
def init_gclient(self):
storage = Storage(CredentialsModel, 'id', self._user, 'credential')
credential = storage.get()
if credential is None or credential.invalid == True:
raise InvalidCredentialException()
else:
self.client = get_gclient(credential)
def get_credential(profile, required=False):
"""Get stored credential for current user profile"""
storage = Storage(EdmodoCredential, 'profile', profile, 'credential')
credential = storage.get()
if credential is None and required:
raise Exception('Edmodo credential not found')
return credential
def driveUpload(user, FILENAME):
storage = Storage(CredentialsModel, 'id', user, 'credential')
credential = storage.get()
if credential is None or credential.invalid == True:
return HttpResponseRedirect("/login/")
else:
# Path to the file to upload
#FILENAME = filePath
fdir, fname = os.path.split(FILENAME)
http = httplib2.Http()
http = credential.authorize(http)
drive_service = build("drive", "v2", http=http)
# Insert a file
media_body = MediaFileUpload(FILENAME, mimetype='application/sst', resumable=True)
body = {
'title': fname,
'mimeType': 'application/sst'
}
file = drive_service.files().insert(body=body, media_body=media_body).execute()
return True
def index(request):
storage = Storage(GcalCredentials, '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)
people = service.people()
peoplelist = people.list(collection='visible',
userId='me').execute()
logging.info(peoplelist)
return render_to_response('gmail/welcome.html', {
'peoplelist': peoplelist,
})
"""
http = httplib2.Http()
http = credential.authorize(http)
service = build('calendar', 'v3', http=http)
calendar_id, created = get_or_create_calendar(service, request.user)
calendar_dict = service.calendarList().get(calendarId=calendar_id).execute()
return render_to_response('googlecalendar/index.html', {
'calendar': calendar_dict,
'created': created,
})
def index(request):
storage = Storage(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 render(request, 'utube/index.html', {'login_url': authorize_url})
else:
user = AuthUser.objects.get(pk=request.user.id)
video_count = user.uservideo_set.count()
print video_count
if not video_count:
http = httplib2.Http()
http = credential.authorize(http)
service = build('youtube', 'v3', http=http)
update_user_infos(user, service)
videos = Video.objects.raw(
'''
SELECT DISTINCT v.* FROM utube_video v LEFT JOIN utube_uservideo uv
ON uv.video_id = v.youtube_id
WHERE uv.user_id = %s
''', [user.id])
return render(request, 'utube/index.html', {'videos': videos})
def purchase_item(request):
action = request.POST['action']
item = action[6:]
size = item.split()[0]
if size == "tiny":
price = 1
elif size == "small":
price = 3
elif size == "big":
price = 10
else:
request.session['message'] = "Can't %s?!?" % action
return HttpResponseRedirect(reverse('GloebitEx:index'))
username = request.session.get('username', None)
storage = Storage(CredentialModel, 'user', username, 'credential')
credential = storage.get()
try:
balance = MERCHANT.purchase_item(credential, item, price)
request.session['balance'] = balance
except gloebit.AccessTokenError:
request.session['message'] = "Stale token! Logout and enter again"
else:
request.session['message'] = "You bought a %s." % item
return HttpResponseRedirect(reverse('GloebitEx:index'))
def checkAuth(request):
"""Checks OAuth status of user, if not
initiates exchange with google's OAuth server
"""
REDIRECT_URI = "http://%s%s" % (request.get_host(),
reverse("oauth2return"))
FLOW = flow_from_clientsecrets(
CLIENT_SECRETS,
scope='https://www.googleapis.com/auth/calendar.readonly',
redirect_uri=REDIRECT_URI
)
user = request.user
storage = Storage(CredentialsModel, 'id', user, 'credential')
credential = storage.get()
if credential is None or credential.invalid is True or not user.userPointer.isOAuthed:
FLOW.params['state'] = xsrfutil.generate_token(
settings.SECRET_KEY, user)
authorize_url = FLOW.step1_get_authorize_url()
f = FlowModel(id=user, flow=FLOW)
f.save()
calUser = CalendarUser.objects.get(user=user)
calUser.isOAuthed = True
calUser.save()
return HttpResponseRedirect(authorize_url)
else:
return HttpResponseRedirect(reverse('main'))
def auth(request):
# use the first REDIRECT_URI if you are developing your app locally, and the second in production
#REDIRECT_URI = 'http://localhost:8000/gmail_setup/callback'
REDIRECT_URI = "http://%s%s" % (BASE_URL, reverse("oauth2:return"))
#REDIRECT_URI = 'https://' + BASE_URL + '/gmail_setup/callback'
print "ACCESSING CLIENT SECRETS"
with open(CLIENT_SECRETS) as json_data:
d = json.load(json_data)
print "DATA:", d
FLOW = flow_from_clientsecrets(
CLIENT_SECRETS,
scope='https://www.googleapis.com/auth/contacts.readonly https://www.googleapis.com/auth/gmail.readonly https://www.googleapis.com/auth/gmail.settings.basic https://www.googleapis.com/auth/gmail.modify',
redirect_uri=REDIRECT_URI
)
FLOW.params['access_type'] = 'offline'
user = request.user
storage = Storage(CredentialsModel, 'id', user, 'credential')
credential = storage.get()
if not credential or credential.invalid:
if 'group' in request.GET:
group_name = request.GET['group']
FLOW.params['state'] = xsrfutil.generate_token(settings.SECRET_KEY, user) + '___' + group_name
authorize_url = FLOW.step1_get_authorize_url()
f = FlowModel(id=user, flow=FLOW)
f.save()
return HttpResponseRedirect(authorize_url)
else:
return HttpResponseRedirect("/gmail_setup")
else:
return HttpResponseRedirect("/gmail_setup")
def delete_credential(profile):
"""Delete credential for current user profile"""
storage = Storage(EdmodoCredential, 'profile', profile, 'credential')
credential = storage.get()
if credential is None:
raise Exception('Edmodo credential not found')
storage.delete()
def driveUpload(user, FILENAME):
storage = Storage(CredentialsModel, "id", user, "credential")
credential = storage.get()
if credential is None or credential.invalid == True:
# return HttpResponseRedirect("/login/")
return render_to_response("google-login-wait.html", {})
else:
# Path to the file to upload
# FILENAME = filePath
fdir, fname = os.path.split(FILENAME)
http = httplib2.Http()
http = credential.authorize(http)
drive_service = build("drive", "v2", http=http)
# Insert a file
media_body = MediaFileUpload(FILENAME, mimetype="application/sst", resumable=True)
body = {"title": fname, "description": "Simple Sheets Worksheet", "mimeType": "application/sst"}
file = drive_service.files().insert(body=body, media_body=media_body).execute()
return file["id"]
def auth(request):
# use the first REDIRECT_URI if you are developing your app locally, and the second in production
#REDIRECT_URI = 'http://localhost:8000/gmail_setup/callback'
REDIRECT_URI = "http://%s%s" % (BASE_URL, reverse("oauth2:return"))
#REDIRECT_URI = 'https://' + BASE_URL + '/gmail_setup/callback'
print "ACCESSING CLIENT SECRETS"
with open(CLIENT_SECRETS) as json_data:
d = json.load(json_data)
print "DATA:", d
FLOW = flow_from_clientsecrets(
CLIENT_SECRETS,
scope=
'https://www.googleapis.com/auth/contacts.readonly https://www.googleapis.com/auth/gmail.readonly https://www.googleapis.com/auth/gmail.settings.basic https://www.googleapis.com/auth/gmail.modify',
redirect_uri=REDIRECT_URI)
FLOW.params['access_type'] = 'offline'
user = request.user
storage = Storage(CredentialsModel, 'id', user, 'credential')
credential = storage.get()
if not credential or credential.invalid:
if 'group' in request.GET:
group_name = request.GET['group']
FLOW.params['state'] = xsrfutil.generate_token(
settings.SECRET_KEY, user) + '___' + group_name
authorize_url = FLOW.step1_get_authorize_url()
f = FlowModel(id=user, flow=FLOW)
f.save()
return HttpResponseRedirect(authorize_url)
else:
return HttpResponseRedirect("/gmail_setup")
else:
return HttpResponseRedirect("/gmail_setup")
def index(request):
storage = Storage(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 render(request, 'utube/index.html',
{'login_url': authorize_url})
else:
user = AuthUser.objects.get(pk=request.user.id)
video_count = user.uservideo_set.count()
print video_count
if not video_count:
http = httplib2.Http()
http = credential.authorize(http)
service = build('youtube', 'v3', http=http)
update_user_infos(user, service)
videos = Video.objects.raw(
'''
SELECT DISTINCT v.* FROM utube_video v LEFT JOIN utube_uservideo uv
ON uv.video_id = v.youtube_id
WHERE uv.user_id = %s
''', [user.id])
return render(request, 'utube/index.html', {'videos': videos})
def index(request):
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
credential = storage.get()
if credential is None or credential.invalid == True:
flow = OAuth2WebServerFlow(
client_id='[[Insert Client ID here.]]',
client_secret='[[Insert Client Secret here.]]',
scope='https://www.googleapis.com/auth/plus.me',
user_agent='plus-django-sample/1.0',
)
authorize_url = flow.step1_get_authorize_url(STEP2_URI)
f = FlowModel(id=request.user, flow=flow)
f.save()
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_to_response('plus/welcome.html', {
'activitylist': activitylist,
})
def wrapper(request, *args, **kwargs):
def oauth2_step1():
state = {
# token to check on redirect
'token': xsrfutil.generate_token(settings.SECRET_KEY, request.user)
}
# extra params that need to be kept over the auth process
if 'oauth2_state' in kwargs:
state['oauth2_state'] = kwargs['oauth2_state']
# encode the whole stuff
base64_state = base64.urlsafe_b64encode(str(json.dumps(state)))
# set the oauth2 state param
self.flow.params['state'] = base64_state
authorize_url = self.flow.step1_get_authorize_url()
return HttpResponseRedirect(authorize_url)
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
credential = storage.get()
if credential is None or credential.invalid is True:
return oauth2_step1()
else:
# refresh credential if needed
if credential.access_token_expired:
try:
credential.refresh(httplib2.Http())
except AccessTokenRefreshError:
return oauth2_step1()
# remove existing oauth2_state params
if 'oauth2_state' in kwargs:
del kwargs['oauth2_state']
return view_function(request, *args, **kwargs)
def _get_user_credentials(self, user):
from orders_manager.models import CredentialsModel
user = user if not hasattr(user, 'user') else user.user
try:
storage = Storage(CredentialsModel, 'id', user, 'credential')
credential = storage.get()
except:
raise ValueError('Credentials for user \'%s\' was not found!' %
user.profile.get_full_name())
if not credential:
raise ValueError('User \'%s\' has no credentials' %
user.profile.get_full_name())
if credential.invalid:
raise ValueError('Credentials are invalid for user \'%s\'!' %
user.profile.get_full_name())
try:
if credential.access_token_expired:
http = credential.authorize(httplib2.Http())
credential.refresh(http)
except Exception as ex:
raise ValueError('Bad user credentials! ' + ex.args[0])
return credential
def init_gclient(self):
storage = Storage(CredentialsModel, 'id', self._user, 'credential')
credential = storage.get()
if credential is None or credential.invalid == True:
raise InvalidCredentialException()
else:
self.client = get_gclient(credential)
def table2sql(request,id=0):
bucket_name = '';
if id:
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
credential = storage.get()
http1 = httplib2.Http()
http2 = credential.authorize(http1)
service = build("drive", "v2", http=http2)
# files = service.files().list().execute()
# request = service.files().get_media(fileId=id)
# local_fd = open('workfile', 'w');
# media_request = http.MediaIoBaseDownload(local_fd, request)
# close f;
# Retry transport and file IO errors.
RETRYABLE_ERRORS = (httplib2.HttpLib2Error, IOError)
# Number of times to retry failed downloads.
NUM_RETRIES = 5
# Number of bytes to send/receive in each request.
CHUNKSIZE = 2 * 1024 * 1024
# Mimetype to use if one can't be guessed from the file extension.
DEFAULT_MIMETYPE = 'application/octet-stream'
print 'Building download request...'
filename = 'xxx'
f = file(filename, 'w')
request = service.files().get_media(fileId=id)
media = http.MediaIoBaseDownload(f, request, chunksize=CHUNKSIZE)
print 'Downloading bucket: %s object: %s to file: %s' % (bucket_name,
id,
filename)
progressless_iters = 0
done = False
while not done:
error = None
try:
progress, done = media.next_chunk()
if progress:
print_with_carriage_return(
'Download %d%%.' % int(progress.progress() * 100))
except HttpError, err:
error = err
if err.resp.status < 500:
raise
except RETRYABLE_ERRORS, err:
error = err
if error:
progressless_iters += 1
handle_progressless_iter(error, progressless_iters)
else:
progressless_iters = 0
def authorize(request):
# Fetch client info from settings.
client_id = settings.GA_CLIENT_ID
client_secret = settings.GA_CLIENT_SECRET
redirect_uri = settings.GA_REDIRECT_URI
scope = settings.GA_SCOPE
# Load previously stored credentials if available.
storage = Storage(Credentials, 'client_id', client_id, 'credentials')
credentials = storage.get()
# If credentials could not be found authorize.
if credentials is None or credentials.invalid is True:
FLOW = OAuth2WebServerFlow(
client_id=client_id,
client_secret=client_secret,
scope=scope,
redirect_uri=redirect_uri,
)
authorize_url = FLOW.step1_get_authorize_url()
return HttpResponseRedirect(authorize_url)
# Otherwise return to admin home with success message.
else:
messages.info(request, 'Previously authorized %s.' % client_id)
return HttpResponseRedirect(reverse('admin:index'))
def index(request):
storage = Storage(CredentialsModel, 'user', request.user, 'credential')
credential = storage.get()
if credential is None or credential.invalid == True:
request.session["scope"] = "admin.directory.user"
FLOW = get_flow("admin.directory.user")
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("admin", "directory_v1", http=http)
results = service.users().list(
customer='carthage.edu', maxResults=10,
orderBy='email', viewType='domain_public'
).execute()
return render_to_response(
'directory/index.html', {'users': users,},
context_instance=RequestContext(request)
)
def require_google_login(request):
storage = Storage(CredentialsModel, 'id', request.session.session_key, 'credential')
credential = storage.get()
if credential is None or credential.invalid == True:
flow = OAuth2WebServerFlow(client_id=settings.GOOGLE_OAUTH_KEY,
client_secret=settings.GOOGLE_OAUTH_SECRET,
scope='https://www.googleapis.com/auth/plus.login https://www.googleapis.com/auth/userinfo.email',
user_agent='plus-django-sample/1.0',
state=request.GET['next'])
authorize_url = flow.step1_get_authorize_url(settings.GOOGLE_RETURN_URL)
f = FlowModel(id=request.session.session_key, flow=flow)
f.save()
return redirect(authorize_url)
http = httplib2.Http()
plus = build('plus', 'v1', http=http)
credential.authorize(http)
name_data = plus.people().get(userId='me').execute()
name = name_data["name"]["givenName"]
last_name = name_data["name"]["familyName"]
plus = build('oauth2', 'v2', http=http)
credential.authorize(http)
email_data = plus.userinfo().get().execute()
email = email_data["email"]
return _login_user(request, email, name, last_name, email)
def index(request):
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
credential = storage.get()
# return render_to_response("accounts/welcome.html", {'activitylist': ['ddss','asdasd','3ed23d32d']})
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("drive", "v2", http=http)
files = service.files().list().execute()
#print json.dumps(files)
#simport pdb; pdb.set_trace()
return render_to_response('accounts/welcome.html', {
'activitylist': files,
})
def _authorize_client(user, gclient):
storage = Storage(CredentialsModel, 'id', user, 'credential')
credential = storage.get()
if credential is None or credential.invalid == True:
raise Exception("Invalid credentials")
gclient = credential.authorize_gclient(gclient)
return gclient
def get_credential(self):
storage = Storage(authentication_models.CredentialsModel,
'id', self.user, 'credential')
credential = storage.get()
if credential is None or credential.invalid:
raise CredentialsError('Credentials not found or invalid.')
return credential
def index(request):
storage = Storage(CredentialsModel, 'user', request.user, 'credential')
credential = storage.get()
if credential is None or credential.invalid == True:
request.session["scope"] = "admin.directory.user"
FLOW = get_flow("admin.directory.user")
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("admin", "directory_v1", http=http)
results = service.users().list(
customer='carthage.edu', maxResults=10,
orderBy='email', viewType='domain_public'
).execute()
return render(
request, 'directory/index.html', {'users': users,}
)
def get_credentials(self):
"""
gets credentials from Storage
"""
storage = Storage(Credentials, 'id', self.request.user, 'credential')
credentials = storage.get()
return credentials
def index(request):
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
credential = storage.get()
if credential is None or credential.invalid == True:
flow = OAuth2WebServerFlow(
client_id='837647042410.apps.googleusercontent.com',
client_secret='+SWwMCL9d8gWtzPRa1lXw5R8',
scope='https://www.googleapis.com/auth/buzz',
user_agent='buzz-django-sample/1.0',
)
authorize_url = flow.step1_get_authorize_url(STEP2_URI)
f = FlowModel(id=request.user, flow=flow)
f.save()
return HttpResponseRedirect(authorize_url)
else:
http = httplib2.Http()
http = credential.authorize(http)
service = build("buzz", "v1", http=http)
activities = service.activities()
activitylist = activities.list(scope='@consumption',
userId='@me').execute()
logging.info(activitylist)
return render_to_response('buzz/welcome.html', {
'activitylist': activitylist,
})
def check_api_token(request, master):
storage = Storage(CredentialsYoutubeModel, 'id', master, 'credential')
credential = storage.get()
# Si les autorisation n'ont pas été données où sont devenue invalides
if credential is None or credential.invalid is True:
get_flow().params['state'] = xsrfutil.generate_token(settings.SECRET_KEY, master)
authorize_url = get_flow().step1_get_authorize_url()
# si l'utilisateur connecté est un admin, il doit mettre à jour les autorisations
if request.user.is_superuser:
context = {
'title': "On a besoin de vous !",
'message': "Bienvenue ! Comme tu peux le voir c'est la guerre ici, tout ne marche pas comme prévu ... "
"Mais heureusement que tu es là ! "
"Le président ne veut plus nous subventionner "
"(c'est plutôt son compte youtube qui ne nous est plus accessible ...) ! "
"Convaincs-le, et récupère nous ses autorisations ! Son nom est : SpamWeb. "
"Tu as carte blanche "
"(tu pourrais par exemple te connecter à son compte google avant de continuer ...) ! "
"Allez juste un dernier conseil : "
"tu devrais essayer [email protected] / spamnocturne. Bonne chance !",
'url_for_admin': authorize_url
}
return {'status': False, 'value': render_to_response('spamusic/message.html', context)}
else:
context = {
'title': "Oups ...",
'message': "Le compte youtube de SpamWeb a besoin de mettre ses autorisations à jour. "
"Veuillez contacter un administrateur"
}
return {'status': False, 'value': render_to_response('spamusic/message.html', context)}
return {'status': True, 'value': credential}
def index(request):
storage = Storage(GmailCredentials, '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)
people = service.people()
peoplelist = people.list(collection='visible',
userId='me').execute()
logging.info(peoplelist)
return render_to_response('gmail/welcome.html', {
'peoplelist': peoplelist,
})
"""
imapobj = GMail_IMAP('imap.gmail.com')
imapobj.login_oauth2(request.user.email, credential)
messagelist = list(imapobj.gmsearch_messages('label:!projekt-vlab-test'))
return render_to_response('gmail/welcome.html', {
'messagelist': messagelist,
})
def update_user_credentials(self, new_credential):
from orders_manager.models import CredentialsModel, User
user = User.objects.get(
email=self.get_google_user_email(new_credential))
storage = Storage(CredentialsModel, 'id', user, 'credential')
storage.put(new_credential)
return storage.get()
def get_stored_credential(request):
google_id = None
credential = None
if request.session.get('google_id', False):
google_id = str(request.session.get('google_id'))
storage = Storage(CredentialsModel, 'id', google_id, 'credential')
credential = storage.get()
return credential
def update_user_credentials(self, new_credential):
from orders_manager.models import CredentialsModel, User
user = User.objects.get(
email=self.get_google_user_email(new_credential))
storage = Storage(CredentialsModel, 'id', user, 'credential')
storage.put(new_credential)
return storage.get()
def confirm_authentication(view,
login_form_uri=None,
login_post_uri=None,
login_done_uri=None,
continuation_url=None,
scope=SCOPE_DEFAULT):
"""
Return None if required authentication is present, otherwise
a login redirection response to the supplied URI
view.credential is set to credential that can be used to access resource
"""
if view.request.user.is_authenticated():
storage = Storage(CredentialsModel, 'id', view.request.user,
'credential')
view.credential = storage.get()
# log.info("view.credential %r"%(view.credential,))
if view.credential is not None:
if not view.credential.invalid:
return None # Valid credential present: proceed...
else:
# Django login with local credential: check for user email address
#
# @@TODO: is this safe?
#
# NOTE: currently, view.credential is provided by the oauth2 and used
# only for the .invalid test above. If it is ever used by other
# application components, it may be necessary to construct a
# credential for local logins. In the long run, if credentials will
# be used to access third party services or resources, it may not be
# possible to use non-Oauth2 credentials here. In the meanwhile,
# allowing local Django user credentials provides an easier route for
# getting a software instance installed for evaluation purposes.
#
if view.request.user.email:
return None # Assume valid login: proceed...
else:
return error400values(view, "Local user has no email address")
if not login_form_uri:
return error400values(view, "No login form URI specified")
if not login_done_uri:
return error400values(view, "No login completion URI specified")
if not login_post_uri:
login_post_uri = login_form_uri
if not continuation_url:
continuation_url = view.request.path
# Redirect to initiate login sequence
view.request.session['login_form_uri'] = login_form_uri
view.request.session['login_post_uri'] = login_post_uri
view.request.session['login_done_uri'] = login_done_uri
view.request.session['continuation_url'] = continuation_url
view.request.session['oauth2_scope'] = scope
query_params = ({
"continuation": continuation_url,
"scope": scope,
"message": ""
})
return HttpResponseRedirectWithQuery(login_form_uri, query_params)
def table2sql(request, id=0):
bucket_name = ''
if id:
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
credential = storage.get()
http1 = httplib2.Http()
http2 = credential.authorize(http1)
service = build("drive", "v2", http=http2)
# files = service.files().list().execute()
# request = service.files().get_media(fileId=id)
# local_fd = open('workfile', 'w');
# media_request = http.MediaIoBaseDownload(local_fd, request)
# close f;
# Retry transport and file IO errors.
RETRYABLE_ERRORS = (httplib2.HttpLib2Error, IOError)
# Number of times to retry failed downloads.
NUM_RETRIES = 5
# Number of bytes to send/receive in each request.
CHUNKSIZE = 2 * 1024 * 1024
# Mimetype to use if one can't be guessed from the file extension.
DEFAULT_MIMETYPE = 'application/octet-stream'
print 'Building download request...'
filename = 'xxx'
f = file(filename, 'w')
request = service.files().get_media(fileId=id)
media = http.MediaIoBaseDownload(f, request, chunksize=CHUNKSIZE)
print 'Downloading bucket: %s object: %s to file: %s' % (bucket_name,
id, filename)
progressless_iters = 0
done = False
while not done:
error = None
try:
progress, done = media.next_chunk()
if progress:
print_with_carriage_return('Download %d%%.' %
int(progress.progress() * 100))
except HttpError, err:
error = err
if err.resp.status < 500:
raise
except RETRYABLE_ERRORS, err:
error = err
if error:
progressless_iters += 1
handle_progressless_iter(error, progressless_iters)
else:
progressless_iters = 0
def handle(self, *args, **options):
config = {
u'metrics': [
u'annotationClickThroughRate',
u'annotationCloseRate',
u'averageViewDuration',
u'comments',
u'dislikes',
u'estimatedMinutesWatched',
u'favoritesAdded',
u'favoritesRemoved',
u'likes',
u'shares',
u'subscribersGained',
u'subscribersLost',
u'views',
],
u'dimensions': [
u'day',
],
u'start_date': u'2014-03-01',
u'end_date': u'2014-03-19',
u'start_index': 1,
u'max_results': 100,
}
if args:
aycs = AnalyticsYoutubeChannel.objects.filter(
youtube_channel__youtube_id__in=args, first_load=False, deleted=False)
else:
aycs = AnalyticsYoutubeChannel.objects.filter(first_load=False, deleted=False)
for ayc in aycs:
storage = Storage(AnalyticsYoutubeChannel, 'email', ayc.email, 'credential')
credential = storage.get()
if credential is None or credential.invalid == True:
CommandError(u'YoutubeConnection is invalid')
http = httplib2.Http()
http = credential.authorize(http)
service = build('youtubeAnalytics', 'v1', http=http)
analytics_response = service.reports().query(
ids="channel==%s" % ayc.youtube_channel.youtube_id,
metrics=u','.join(config[u'metrics']),
dimensions=u','.join(config[u'dimensions']),
start_date=config[u'start_date'],
end_date=config[u'end_date'],
start_index=config[u'start_index'],
max_results=config[u'max_results'],
).execute()
for column_header in analytics_response.get("columnHeaders", []):
print "%-20s" % column_header["name"],
for row in analytics_response.get("rows", []):
for value in row:
print "%-20s" % value,
def syncGoogleAccount(request):
if request.method == 'POST':
oldUserID = request.POST['oldUserID']
newUserID = request.POST['newUserID']
if User.objects.filter(id=oldUserID):
resetThisUser = User.objects.get(id=oldUserID)
else:
return HttpResponse(json.dumps({'error':'Sorry, we are having an issue linking your google account.'}))
if User.objects.filter(id=newUserID):
deleteThisUser = User.objects.get(id=newUserID)
else:
return HttpResponse(json.dumps({'error':'Sorry, we are having an issue linking your google account.'}))
#reset google account to oldUserID and delete newUserID
if GoogleUserInfo.objects.filter(user=deleteThisUser):
googleAccount = GoogleUserInfo.objects.get(user=deleteThisUser)
#get the storage from deleteUser
oldStorage = Storage(CredentialsModel, 'id', deleteThisUser, 'credential')
credential = oldStorage.get()
#create a new storage for resetUser
newStorage = Storage(CredentialsModel, 'id', resetThisUser, 'credential')
newStorage.put(credential)
#delete old credential for deleteUser
oldStorage.delete()
#reset email from deleteUser to resetUser to make them the same
resetThisUser.email = deleteThisUser.email
resetThisUser.save()
#log in resetUser
resetThisUser.backend = 'django.contrib.auth.backends.ModelBackend'
login(request, resetThisUser)
#set new userID for session
request.session['user_id'] = resetThisUser.id
request.session.set_expiry(604800)
#set to old account
googleAccount.user = resetThisUser
googleAccount.save()
#delete deleteUser
deleteThisUser.delete()
data = {'success':'success'}
else:
return HttpResponse(json.dumps({'error':'Sorry, we are having an issue linking your google account.'}))
else:
data = {'error':'Did not post correctly'}
return HttpResponse(json.dumps(data))
def get_storage_flow_secret(scope):
flow = flow_from_clientsecrets(
scope_secret,
scope=scope_urls[scope],
redirect_uri=settings.YOUTUBE_REDIRECT_URL + scope,
)
storage = Storage(CredentialsModel, 'id', scope_users[scope], 'credential')
credential = storage.get()
return flow, credential
def index(request):
REDIRECT_URI = 'http://localhost:8000/oauth2/oauth2callback'
# REDIRECT_URI = "https://%s%s" % (
# get_current_site(request).domain, reverse("oauth2:return"))
FLOW = flow_from_clientsecrets(
CLIENT_SECRETS,
scope='https://www.googleapis.com/auth/youtube.readonly',
redirect_uri=REDIRECT_URI
)
user = request.user
storage = Storage(CredentialsModel, 'id', user, 'credential')
credential = storage.get()
if credential is None or credential.invalid is True:
FLOW.params['state'] = xsrfutil.generate_token(
settings.SECRET_KEY, user)
authorize_url = FLOW.step1_get_authorize_url()
f = FlowModel(id=user, flow=FLOW)
f.save()
return HttpResponseRedirect(authorize_url)
else:
http = httplib2.Http()
http = credential.authorize(http)
youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION, http=http)
channels_response = youtube.channels().list(
mine=True,
part="contentDetails"
).execute()
for channel in channels_response["items"]:
wh_list_id = channel["contentDetails"]["relatedPlaylists"]["watchHistory"]
playlistitems_list_response = youtube.playlistItems().list(
playlistId=wh_list_id,
part="snippet",
maxResults=50,
).execute()
video_id = []
for playlist_item in playlistitems_list_response["items"]:
video_id.append(playlist_item["snippet"]["resourceId"]["videoId"])
video_ids = ','.join(video_id)
video_response = youtube.videos().list(
id=video_ids,
part='snippet',
).execute()
titles = []
video_id = []
for vr in video_response['items']:
if vr['snippet']['categoryId'] == "10":
titles.append(vr["snippet"]["title"])
video_id.append("https://www.youtube.com/watch?v=" + vr['id'])
details = zip(titles, video_id)
# pdb.set_trace()
return details
def get_service():
user = User.objects.get(username='******')
storage = Storage(CredentialsModel, 'id', user, 'credential')
credential = storage.get()
http = httplib2.Http()
http = credential.authorize(http)
service = build("analytics", "v3", http=http)
return service
def update_gmail_filter(user, group_name, whitelist_emails, filter_hash):
storage = Storage(CredentialsModel, 'id', user, 'credential')
credential = storage.get()
http = httplib2.Http()
http = credential.authorize(http)
service_mail = build('gmail', 'v1', http=http)
forward_address = '%s@%s' % (group_name, BASE_URL)
return True
def oauth_service(user, *args):
storage = Storage(models.Credentials, 'user', user, 'credential')
credential = storage.get()
if not credential or credential.invalid:
logging.error('Invalid credentials for {}'.format(user))
else:
logging.info('Loading service {}'.format(args))
http = httplib2.Http()
http = credential.authorize(http)
return build(*args, http=http)
def build_services(user):
storage = Storage(CredentialsModel, 'id', user, 'credential')
credential = storage.get()
if credential and not credential.invalid:
http = httplib2.Http()
http = credential.authorize(http)
credential.refresh(http)
service_people = build('people', 'v1', http=http)
service_mail = build('gmail', 'v1', http=http)
return {'mail' : service_mail, 'people' : service_people}
def get(self, request, format=None):
user = request.user
storage = Storage(CredentialsModel, 'id', user, 'credential')
credentials = storage.get()
http_auth = credentials.authorize(httplib2.Http())
service = build('gmail', 'v1', http=http_auth)
user_Id = user.username
label_id = request.GET['label']
all_mails = UserData.objects.filter(user_id=user,
label=label_id).values()
return Response(all_mails)
def get(self, *args, **kwargs):
storage = Storage(Credential, 'id', self.request.user, 'credential')
credential = storage.get()
if credential is None or credential.invalid is True:
self.FLOW.params['state'] = xsrfutil.generate_token(
settings.SECRET_KEY, self.request.user)
self.FLOW.params['approval_prompt'] = 'force'
authorize_url = self.FLOW.step1_get_authorize_url()
return HttpResponseRedirect(authorize_url)
else:
return HttpResponseRedirect(reverse("summon_adsense_stat", kwargs={'days_before': 1}))
def index(request):
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
credential = storage.get()
if credential is None or credential.invalid:
FLOW.params['state'] = xsrfutil.generate_token(SECRET_KEY,
str(request.user))
authorize_url = FLOW.step1_get_authorize_url()
return HttpResponseRedirect(authorize_url)
return HttpResponseRedirect('/admin')
def google(request):
storage = Storage(Credentials, 'id', request.user, 'google_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:
redirect_url = request.session.pop('oauth_callback_redirect', 'google_calendar_sync_run')
return redirect(redirect_url)
def remove_from_group(self, mailing_list):
storage = Storage(CredentialsModel, 'id', self.creator, 'credential')
credential = storage.get()
if credential is None or credential.invalid:
return False
mail = mailing_list.email
http_auth = credential.authorize(httplib2.Http())
service = build('admin', 'directory_v1', http=http_auth)
create = service.members().delete(groupKey=mail, memberKey=self.email)
return create.execute()
def add_to_group(self, mailing_list):
storage = Storage(CredentialsModel, 'id', self.creator, 'credential')
credential = storage.get()
if credential is None or credential.invalid:
return False
mail = mailing_list.email
post_data = {'email': self.email, 'role': 'MEMBER'}
http_auth = credential.authorize(httplib2.Http())
service = build('admin', 'directory_v1', http=http_auth)
create = service.members().insert(groupKey=mail, body=post_data)
return create.execute()
def get_tasks_service(request):
storage = Storage(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)
tasks_service = build("tasks", "v1", http=http)
return tasks_service
def get(self, request, format=None):
user = request.user
storage = Storage(CredentialsModel, 'id', user, 'credential')
credentials = storage.get()
http_auth = credentials.authorize(httplib2.Http())
service = build('gmail', 'v1', http=http_auth)
user_Id = user.username
download_request = BulkRequestId.objects.filter(
request_id__startswith=user_Id)
request_data = {"request_detail": download_request}
return render(request,
'mydownload.html',
request_data,
context_instance=RequestContext(request))
