def login_user(request):
"""
This method is called when you login from the /login/ form
:param request:
:return:
"""
voter_api_device_id = get_voter_api_device_id(request) # We look in the cookies for voter_api_device_id
store_new_voter_api_device_id_in_cookie = False
voter_signed_in = False
voter_manager = VoterManager()
voter_device_link_manager = VoterDeviceLinkManager()
results = voter_manager.retrieve_voter_from_voter_device_id(voter_api_device_id)
if results['voter_found']:
voter_on_stage = results['voter']
voter_on_stage_id = voter_on_stage.id
# Just because a We Vote voter is found doesn't mean they are authenticated for Django
else:
voter_on_stage_id = 0
info_message = ''
error_message = ''
username = ''
# Does Django think user is already signed in?
if request.user.is_authenticated():
# If so, make sure user and voter_on_stage are the same.
if request.user.id != voter_on_stage_id:
# Delete the prior voter_api_device_id from database
voter_device_link_manager.delete_voter_device_link(voter_api_device_id)
# Create a new voter_api_device_id and voter_device_link
voter_api_device_id = generate_voter_device_id()
results = voter_device_link_manager.save_new_voter_device_link(voter_api_device_id, request.user.id)
store_new_voter_api_device_id_in_cookie = results['voter_device_link_created']
voter_on_stage = request.user
voter_on_stage_id = voter_on_stage.id
elif request.POST:
username = request.POST.get('username')
password = request.POST.get('password')
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
info_message = "You're successfully logged in!"
# Delete the prior voter_api_device_id from database
voter_device_link_manager.delete_voter_device_link(voter_api_device_id)
# Create a new voter_api_device_id and voter_device_link
voter_api_device_id = generate_voter_device_id()
results = voter_device_link_manager.save_new_voter_device_link(voter_api_device_id, user.id)
store_new_voter_api_device_id_in_cookie = results['voter_device_link_created']
else:
error_message = "Your account is not active, please contact the site admin."
if user.id != voter_on_stage_id:
# Eventually we want to merge voter_on_stage into user account
pass
else:
error_message = "Your username and/or password were incorrect."
elif not positive_value_exists(voter_on_stage_id):
# If here, delete the prior voter_api_device_id from database
voter_device_link_manager.delete_voter_device_link(voter_api_device_id)
# We then need to set a voter_api_device_id cookie and create a new voter (even though not signed in)
results = voter_setup(request)
voter_api_device_id = results['voter_api_device_id']
store_new_voter_api_device_id_in_cookie = results['store_new_voter_api_device_id_in_cookie']
# Does Django think user is signed in?
if request.user.is_authenticated():
voter_signed_in = True
else:
info_message = "Please log in below..."
if positive_value_exists(error_message):
messages.add_message(request, messages.ERROR, error_message)
if positive_value_exists(info_message):
messages.add_message(request, messages.INFO, info_message)
messages_on_stage = get_messages(request)
template_values = {
'request': request,
'username': username,
'next': next,
'voter_signed_in': voter_signed_in,
'messages_on_stage': messages_on_stage,
}
response = render(request, 'registration/login_user.html', template_values)
# We want to store the voter_api_device_id cookie if it is new
if positive_value_exists(voter_api_device_id) and positive_value_exists(store_new_voter_api_device_id_in_cookie):
set_voter_api_device_id(request, response, voter_api_device_id)
return response
def generate_voter_device_id(self):
# A simple mapping to this function
return generate_voter_device_id()
def login_user(request):
"""
This method is called when you login from the /login/ form
:param request:
:return:
"""
voter_api_device_id = get_voter_api_device_id(
request) # We look in the cookies for voter_api_device_id
store_new_voter_api_device_id_in_cookie = False
voter_signed_in = False
voter_manager = VoterManager()
voter_device_link_manager = VoterDeviceLinkManager()
results = voter_manager.retrieve_voter_from_voter_device_id(
voter_api_device_id)
if results['voter_found']:
voter_on_stage = results['voter']
voter_on_stage_id = voter_on_stage.id
# Just because a We Vote voter is found doesn't mean they are authenticated for Django
else:
voter_on_stage_id = 0
info_message = ''
error_message = ''
username = ''
# Does Django think user is already signed in?
if request.user.is_authenticated():
# If so, make sure user and voter_on_stage are the same.
if request.user.id != voter_on_stage_id:
# Delete the prior voter_api_device_id from database
voter_device_link_manager.delete_voter_device_link(
voter_api_device_id)
# Create a new voter_api_device_id and voter_device_link
voter_api_device_id = generate_voter_device_id()
results = voter_device_link_manager.save_new_voter_device_link(
voter_api_device_id, request.user.id)
store_new_voter_api_device_id_in_cookie = results[
'voter_device_link_created']
voter_on_stage = request.user
voter_on_stage_id = voter_on_stage.id
elif request.POST:
username = request.POST.get('username')
password = request.POST.get('password')
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
info_message = "You're successfully logged in!"
# Delete the prior voter_api_device_id from database
voter_device_link_manager.delete_voter_device_link(
voter_api_device_id)
# Create a new voter_api_device_id and voter_device_link
voter_api_device_id = generate_voter_device_id()
results = voter_device_link_manager.save_new_voter_device_link(
voter_api_device_id, user.id)
store_new_voter_api_device_id_in_cookie = results[
'voter_device_link_created']
else:
error_message = "Your account is not active, please contact the site admin."
if user.id != voter_on_stage_id:
# Eventually we want to merge voter_on_stage into user account
pass
else:
error_message = "Your username and/or password were incorrect."
elif not positive_value_exists(voter_on_stage_id):
# If here, delete the prior voter_api_device_id from database
voter_device_link_manager.delete_voter_device_link(voter_api_device_id)
# We then need to set a voter_api_device_id cookie and create a new voter (even though not signed in)
results = voter_setup(request)
voter_api_device_id = results['voter_api_device_id']
store_new_voter_api_device_id_in_cookie = results[
'store_new_voter_api_device_id_in_cookie']
# Does Django think user is signed in?
if request.user.is_authenticated():
voter_signed_in = True
else:
info_message = "Please log in below..."
if positive_value_exists(error_message):
messages.add_message(request, messages.ERROR, error_message)
if positive_value_exists(info_message):
messages.add_message(request, messages.INFO, info_message)
messages_on_stage = get_messages(request)
template_values = {
'request': request,
'username': username,
'next': next,
'voter_signed_in': voter_signed_in,
'messages_on_stage': messages_on_stage,
}
response = render(request, 'registration/login_user.html', template_values)
# We want to store the voter_api_device_id cookie if it is new
if positive_value_exists(voter_api_device_id) and positive_value_exists(
store_new_voter_api_device_id_in_cookie):
set_voter_api_device_id(request, response, voter_api_device_id)
return response
def voter_retrieve_for_api(voter_device_id): # voterRetrieve
"""
Used by the api
:param voter_device_id:
:return:
"""
voter_manager = VoterManager()
voter_id = 0
voter_created = False
if positive_value_exists(voter_device_id):
# If a voter_device_id is passed in that isn't valid, we want to throw an error
device_id_results = is_voter_device_id_valid(voter_device_id)
if not device_id_results['success']:
json_data = {
'status': device_id_results['status'],
'success': False,
'voter_device_id': voter_device_id,
'voter_created': False,
'voter_found': False,
}
return json_data
voter_id = fetch_voter_id_from_voter_device_link(voter_device_id)
if not positive_value_exists(voter_id):
json_data = {
'status': "VOTER_NOT_FOUND_FROM_DEVICE_ID",
'success': False,
'voter_device_id': voter_device_id,
'voter_created': False,
'voter_found': False,
}
return json_data
else:
# If a voter_device_id isn't passed in, automatically create a new voter_device_id and voter
voter_device_id = generate_voter_device_id()
# We make sure a voter record hasn't already been created for this new voter_device_id, so we don't create a
# security hole by giving a new person access to an existing account. This should never happen because it is
# so unlikely that we will ever generate an existing voter_device_id with generate_voter_device_id.
existing_voter_id = fetch_voter_id_from_voter_device_link(voter_device_id)
if existing_voter_id:
json_data = {
'status': "VOTER_ALREADY_EXISTS_BUT_ACCESS_RESTRICTED",
'success': False,
'voter_device_id': voter_device_id,
'voter_created': False,
'voter_found': False,
}
return json_data
results = voter_manager.create_voter()
if results['voter_created']:
voter = results['voter']
# Now save the voter_device_link
voter_device_link_manager = VoterDeviceLinkManager()
results = voter_device_link_manager.save_new_voter_device_link(voter_device_id, voter.id)
if results['voter_device_link_created']:
voter_device_link = results['voter_device_link']
voter_id_found = True if voter_device_link.voter_id > 0 else False
if voter_id_found:
voter_id = voter_device_link.voter_id
voter_created = True
if not positive_value_exists(voter_id):
json_data = {
'status': "VOTER_NOT_FOUND_AFTER_BEING_CREATED",
'success': False,
'voter_device_id': voter_device_id,
'voter_created': False,
'voter_found': False,
}
return json_data
# At this point, we should have a valid voter_id
results = voter_manager.retrieve_voter_by_id(voter_id)
if results['voter_found']:
voter = results['voter']
if voter_created:
status = 'VOTER_CREATED'
else:
status = 'VOTER_FOUND'
json_data = {
'status': status,
'success': True,
'voter_device_id': voter_device_id,
'voter_created': voter_created,
'voter_found': True,
'we_vote_id': voter.we_vote_id,
'facebook_id': voter.facebook_id,
'email': voter.email,
'facebook_email': voter.facebook_email,
'facebook_profile_image_url_https': voter.facebook_profile_image_url_https,
'full_name': voter.get_full_name(),
'first_name': voter.first_name,
'last_name': voter.last_name,
'twitter_screen_name': voter.twitter_screen_name,
'signed_in_personal': voter.signed_in_personal(),
'signed_in_facebook': voter.signed_in_facebook(),
'signed_in_google': voter.signed_in_google(),
'signed_in_twitter': voter.signed_in_twitter(),
'linked_organization_we_vote_id': voter.linked_organization_we_vote_id,
'voter_photo_url': voter.voter_photo_url(),
}
return json_data
else:
status = results['status']
json_data = {
'status': status,
'success': False,
'voter_device_id': voter_device_id,
'voter_created': False,
'voter_found': False,
'we_vote_id': '',
'facebook_id': '',
'email': '',
'facebook_email': '',
'facebook_profile_image_url_https': '',
'full_name': '',
'first_name': '',
'last_name': '',
'twitter_screen_name': '',
'signed_in_personal': False,
'signed_in_facebook': False,
'signed_in_google': False,
'signed_in_twitter': False,
'linked_organization_we_vote_id': '',
'voter_photo_url': '',
}
return json_data
def voter_create_for_api(voter_device_id): # voterCreate
# If a voter_device_id isn't passed in, automatically create a new voter_device_id
if not positive_value_exists(voter_device_id):
voter_device_id = generate_voter_device_id()
else:
# If a voter_device_id is passed in that isn't valid, we want to throw an error
results = is_voter_device_id_valid(voter_device_id)
if not results['success']:
return HttpResponse(json.dumps(results['json_data']), content_type='application/json')
voter_id = 0
voter_we_vote_id = ''
# Make sure a voter record hasn't already been created for this
voter_manager = VoterManager()
results = voter_manager.retrieve_voter_from_voter_device_id(voter_device_id)
if results['voter_found']:
voter = results['voter']
voter_id = voter.id
voter_we_vote_id = voter.we_vote_id
json_data = {
'status': "VOTER_ALREADY_EXISTS",
'success': True,
'voter_device_id': voter_device_id,
'voter_id': voter_id,
'voter_we_vote_id': voter_we_vote_id,
}
return HttpResponse(json.dumps(json_data), content_type='application/json')
# Create a new voter and return the voter_device_id
voter_manager = VoterManager()
results = voter_manager.create_voter()
if results['voter_created']:
voter = results['voter']
# Now save the voter_device_link
voter_device_link_manager = VoterDeviceLinkManager()
results = voter_device_link_manager.save_new_voter_device_link(voter_device_id, voter.id)
if results['voter_device_link_created']:
voter_device_link = results['voter_device_link']
voter_id_found = True if voter_device_link.voter_id > 0 else False
if voter_id_found:
voter_id = voter.id
voter_we_vote_id = voter.we_vote_id
if voter_id:
json_data = {
'status': "VOTER_CREATED",
'success': True,
'voter_device_id': voter_device_id,
'voter_id': voter_id,
'voter_we_vote_id': voter_we_vote_id,
}
return HttpResponse(json.dumps(json_data), content_type='application/json')
else:
json_data = {
'status': "VOTER_NOT_CREATED",
'success': False,
'voter_device_id': voter_device_id,
'voter_id': 0,
'voter_we_vote_id': '',
}
return HttpResponse(json.dumps(json_data), content_type='application/json')
def voter_retrieve_for_api(voter_device_id): # voterRetrieve
"""
Used by the api
:param voter_device_id:
:return:
"""
voter_manager = VoterManager()
voter_id = 0
voter_created = False
if positive_value_exists(voter_device_id):
# If a voter_device_id is passed in that isn't valid, we want to throw an error
device_id_results = is_voter_device_id_valid(voter_device_id)
if not device_id_results['success']:
json_data = {
'status': device_id_results['status'],
'success': False,
'voter_device_id': voter_device_id,
'voter_created': False,
'voter_found': False,
}
return json_data
voter_id = fetch_voter_id_from_voter_device_link(voter_device_id)
if not positive_value_exists(voter_id):
json_data = {
'status': "VOTER_NOT_FOUND_FROM_DEVICE_ID",
'success': False,
'voter_device_id': voter_device_id,
'voter_created': False,
'voter_found': False,
}
return json_data
else:
# If a voter_device_id isn't passed in, automatically create a new voter_device_id and voter
voter_device_id = generate_voter_device_id()
# We make sure a voter record hasn't already been created for this new voter_device_id, so we don't create a
# security hole by giving a new person access to an existing account. This should never happen because it is
# so unlikely that we will ever generate an existing voter_device_id with generate_voter_device_id.
existing_voter_id = fetch_voter_id_from_voter_device_link(
voter_device_id)
if existing_voter_id:
json_data = {
'status': "VOTER_ALREADY_EXISTS_BUT_ACCESS_RESTRICTED",
'success': False,
'voter_device_id': voter_device_id,
'voter_created': False,
'voter_found': False,
}
return json_data
results = voter_manager.create_voter()
if results['voter_created']:
voter = results['voter']
# Now save the voter_device_link
voter_device_link_manager = VoterDeviceLinkManager()
results = voter_device_link_manager.save_new_voter_device_link(
voter_device_id, voter.id)
if results['voter_device_link_created']:
voter_device_link = results['voter_device_link']
voter_id_found = True if voter_device_link.voter_id > 0 else False
if voter_id_found:
voter_id = voter_device_link.voter_id
voter_created = True
if not positive_value_exists(voter_id):
json_data = {
'status': "VOTER_NOT_FOUND_AFTER_BEING_CREATED",
'success': False,
'voter_device_id': voter_device_id,
'voter_created': False,
'voter_found': False,
}
return json_data
# At this point, we should have a valid voter_id
results = voter_manager.retrieve_voter_by_id(voter_id)
if results['voter_found']:
voter = results['voter']
if voter_created:
status = 'VOTER_CREATED'
else:
status = 'VOTER_FOUND'
json_data = {
'status': status,
'success': True,
'voter_device_id': voter_device_id,
'voter_created': voter_created,
'voter_found': True,
'we_vote_id': voter.we_vote_id,
'facebook_id': voter.facebook_id,
'email': voter.email,
'facebook_email': voter.facebook_email,
'facebook_profile_image_url_https':
voter.facebook_profile_image_url_https,
'full_name': voter.get_full_name(),
'first_name': voter.first_name,
'last_name': voter.last_name,
'twitter_screen_name': voter.twitter_screen_name,
'signed_in_personal': voter.signed_in_personal(),
'signed_in_facebook': voter.signed_in_facebook(),
'signed_in_google': voter.signed_in_google(),
'signed_in_twitter': voter.signed_in_twitter(),
'linked_organization_we_vote_id':
voter.linked_organization_we_vote_id,
'voter_photo_url': voter.voter_photo_url(),
}
return json_data
else:
status = results['status']
json_data = {
'status': status,
'success': False,
'voter_device_id': voter_device_id,
'voter_created': False,
'voter_found': False,
'we_vote_id': '',
'facebook_id': '',
'email': '',
'facebook_email': '',
'facebook_profile_image_url_https': '',
'full_name': '',
'first_name': '',
'last_name': '',
'twitter_screen_name': '',
'signed_in_personal': False,
'signed_in_facebook': False,
'signed_in_google': False,
'signed_in_twitter': False,
'linked_organization_we_vote_id': '',
'voter_photo_url': '',
}
return json_data
def voter_create_for_api(voter_device_id): # voterCreate
# If a voter_device_id isn't passed in, automatically create a new voter_device_id
if not positive_value_exists(voter_device_id):
voter_device_id = generate_voter_device_id()
else:
# If a voter_device_id is passed in that isn't valid, we want to throw an error
results = is_voter_device_id_valid(voter_device_id)
if not results['success']:
return HttpResponse(json.dumps(results['json_data']),
content_type='application/json')
voter_id = 0
voter_we_vote_id = ''
# Make sure a voter record hasn't already been created for this
voter_manager = VoterManager()
results = voter_manager.retrieve_voter_from_voter_device_id(
voter_device_id)
if results['voter_found']:
voter = results['voter']
voter_id = voter.id
voter_we_vote_id = voter.we_vote_id
json_data = {
'status': "VOTER_ALREADY_EXISTS",
'success': True,
'voter_device_id': voter_device_id,
'voter_id': voter_id,
'voter_we_vote_id': voter_we_vote_id,
}
return HttpResponse(json.dumps(json_data),
content_type='application/json')
# Create a new voter and return the voter_device_id
voter_manager = VoterManager()
results = voter_manager.create_voter()
if results['voter_created']:
voter = results['voter']
# Now save the voter_device_link
voter_device_link_manager = VoterDeviceLinkManager()
results = voter_device_link_manager.save_new_voter_device_link(
voter_device_id, voter.id)
if results['voter_device_link_created']:
voter_device_link = results['voter_device_link']
voter_id_found = True if voter_device_link.voter_id > 0 else False
if voter_id_found:
voter_id = voter.id
voter_we_vote_id = voter.we_vote_id
if voter_id:
json_data = {
'status': "VOTER_CREATED",
'success': True,
'voter_device_id': voter_device_id,
'voter_id': voter_id,
'voter_we_vote_id': voter_we_vote_id,
}
return HttpResponse(json.dumps(json_data),
content_type='application/json')
else:
json_data = {
'status': "VOTER_NOT_CREATED",
'success': False,
'voter_device_id': voter_device_id,
'voter_id': 0,
'voter_we_vote_id': '',
}
return HttpResponse(json.dumps(json_data),
content_type='application/json')
def device_id_generate_view(request):
"""
This API call is used by clients to generate a transient unique identifier (device_id - stored on client)
which ties the device to a persistent voter_id (mapped together and stored on the server).
:param request:
:return: Unique device id that can be stored in a cookie
"""
voter_device_id = generate_voter_device_id() # Stored in cookie elsewhere
logger.debug("apis_v1/views.py, device_id_generate-voter_device_id: {voter_device_id}".format(
voter_device_id=voter_device_id
))
json_data = {
'voter_device_id': voter_device_id,
}
return HttpResponse(json.dumps(json_data), content_type='application/json')
