def test_constructor(self):
storage = Storage(FakeCredentialsModel, self.key_name, self.key_value,
self.property_name)
self.assertEqual(storage.model_class, FakeCredentialsModel)
self.assertEqual(storage.key_name, self.key_name)
self.assertEqual(storage.key_value, self.key_value)
self.assertEqual(storage.property_name, self.property_name)
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 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 _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_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 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 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 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 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 registration(request):
form = SignUpForm()
flow = OAuth2WebServerFlow(*musicmanager.oauth)
auth_uri = flow.step1_get_authorize_url()
args = {'form': form, 'auth_uri': auth_uri}
if request.method == 'POST':
form = SignUpForm(request.POST)
if form.is_valid():
credential = flow.step2_exchange(
form.cleaned_data.get('oauth_code'))
user = form.save()
user.refresh_from_db()
storage = Storage(Profile, 'user', user, 'google_oauth')
storage.put(credential)
raw_password = form.cleaned_data.get('password1')
user = authenticate(username=user.username, password=raw_password)
login(request, user)
return redirect('index')
args.update({'form': form})
return render(request, 'core/register.html', args)
def _get_google_credential(request):
token = None
credential = 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)
if credential:
try:
credential.get_access_token()
except HttpAccessTokenRefreshError:
try:
credential.revoke(httplib2.Http())
except TokenRevokeError:
storage.delete()
if not credential or credential.invalid:
google_flow = generate_google_web_flow(request)
return HttpResponseRedirect(google_flow.step1_get_authorize_url())
return credential
def get_calendar_permission(request):
# This method gets the calendar access permission as soon as user log in
site_user = SiteUser.objects.get(user=request.user)
storage = Storage(SiteUser, 'user', request.user, 'credential')
credential = storage.get()
if credential is None or credential.invalid \
or credential.id_token['email'] != site_user.user.email:
auth_uri = flow.step1_get_authorize_url()
request.session['redirect_url'] = '/get-calendar-permission'
return HttpResponseRedirect(auth_uri)
if site_user.is_salesman and not site_user.notification_enabled:
# if user is sales man then get all data from calendar and enable the push notifications
# Get the service
http = httplib2.Http()
http_authorized = credential.authorize(http)
service = build("calendar", "v3", http=http_authorized)
next_page_token = None
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:
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')
if next_page_token is None:
break
# Enable the push notifications
email = site_user.user.email
url = 'https://www.googleapis.com/calendar/v3/calendars/{email}/events/watch'.format(
email=email)
headers = {
'Content-Type': 'application/json',
'Authorization':
'Bearer ' + credential.get_access_token().access_token
}
data = {
'id':
'notification-channel-id-for-' +
email[:email.index('@')].replace('.', '-'),
"type":
"web_hook",
"address":
"https://cdf1fd5c.ngrok.io/notifications"
}
res = requests.post(url, data=json.dumps(data), headers=headers)
# save channel id
site_user.notification_channel_id = data['id']
site_user.notification_enabled = True
site_user.save()
return HttpResponseRedirect('/home')
