def organization_edit_existing_position_form_view(request, organization_id, position_id):
"""
In edit, you can only change your stance and comments, not who or what the position is about
:param request:
:param organization_id:
:param position_id:
:return:
"""
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
organization_id = convert_to_int(organization_id)
position_id = convert_to_int(position_id)
organization_on_stage_found = False
try:
organization_on_stage = Organization.objects.get(id=organization_id)
organization_on_stage_found = True
except Organization.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
except Organization.DoesNotExist:
# This is fine, create new
pass
if not organization_on_stage_found:
messages.add_message(request, messages.INFO,
'Could not find organization when trying to edit a position.')
return HttpResponseRedirect(reverse('organization:organization_position_list', args=([organization_id])))
# Get the existing position
organization_position_on_stage = PositionEntered()
organization_position_on_stage_found = False
position_entered_manager = PositionEnteredManager()
results = position_entered_manager.retrieve_position_from_id(position_id)
if results['position_found']:
organization_position_on_stage_found = True
organization_position_on_stage = results['position']
if not organization_position_on_stage_found:
messages.add_message(request, messages.INFO,
'Could not find organization position when trying to edit.')
return HttpResponseRedirect(reverse('organization:organization_position_list', args=([organization_id])))
# Note: We have access to the candidate campaign through organization_position_on_stage.candidate_campaign
election_list = Election.objects.all()
if organization_position_on_stage_found:
template_values = {
'is_in_edit_mode': True,
'messages_on_stage': messages_on_stage,
'organization': organization_on_stage,
'organization_position': organization_position_on_stage,
'possible_stances_list': ORGANIZATION_STANCE_CHOICES,
'stance_selected': organization_position_on_stage.stance,
'election_list': election_list,
}
return render(request, 'organization/organization_position_edit.html', template_values)
def measure_summary_view(request, measure_id):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
measure_id = convert_to_int(measure_id)
measure_on_stage_found = False
measure_on_stage = ContestMeasure()
google_civic_election_id = convert_to_int(request.GET.get('google_civic_election_id', 0))
try:
measure_on_stage = ContestMeasure.objects.get(id=measure_id)
measure_on_stage_found = True
except ContestMeasure.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
except ContestMeasure.DoesNotExist:
# This is fine, create new
pass
election_list = Election.objects.order_by('-election_day_text')
if measure_on_stage_found:
template_values = {
'messages_on_stage': messages_on_stage,
'measure': measure_on_stage,
'election_list': election_list,
'google_civic_election_id': google_civic_election_id,
}
else:
template_values = {
'messages_on_stage': messages_on_stage,
}
return render(request, 'measure/measure_summary.html', template_values)
def measure_summary_view(request, measure_id):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
measure_id = convert_to_int(measure_id)
measure_on_stage_found = False
measure_on_stage = ContestMeasure()
google_civic_election_id = convert_to_int(
request.GET.get('google_civic_election_id', 0))
try:
measure_on_stage = ContestMeasure.objects.get(id=measure_id)
measure_on_stage_found = True
except ContestMeasure.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
except ContestMeasure.DoesNotExist:
# This is fine, create new
pass
election_list = Election.objects.order_by('-election_day_text')
if measure_on_stage_found:
template_values = {
'messages_on_stage': messages_on_stage,
'measure': measure_on_stage,
'election_list': election_list,
'google_civic_election_id': google_civic_election_id,
}
else:
template_values = {
'messages_on_stage': messages_on_stage,
}
return render(request, 'measure/measure_summary.html', template_values)
def retrieve_vote_smart_candidate(
self, vote_smart_candidate_id=None, first_name=None, last_name=None, state_code=None):
"""
We want to return one and only one candidate
:param vote_smart_candidate_id:
:param first_name:
:param last_name:
:param state_code:
:return:
"""
error_result = False
exception_does_not_exist = False
exception_multiple_object_returned = False
vote_smart_candidate = VoteSmartCandidate()
try:
if positive_value_exists(vote_smart_candidate_id):
vote_smart_candidate = VoteSmartCandidate.objects.get(candidateId=vote_smart_candidate_id)
vote_smart_candidate_id = convert_to_int(vote_smart_candidate.candidateId)
status = "RETRIEVE_VOTE_SMART_CANDIDATE_FOUND_BY_ID"
elif positive_value_exists(first_name) or positive_value_exists(last_name):
candidate_queryset = VoteSmartCandidate.objects.all()
if positive_value_exists(first_name):
first_name = first_name.replace("`", "'") # Vote Smart doesn't like this kind of apostrophe: `
candidate_queryset = candidate_queryset.filter(Q(firstName__istartswith=first_name) |
Q(nickName__istartswith=first_name) |
Q(preferredName__istartswith=first_name))
if positive_value_exists(last_name):
last_name = last_name.replace("`", "'") # Vote Smart doesn't like this kind of apostrophe: `
candidate_queryset = candidate_queryset.filter(lastName__iexact=last_name)
if positive_value_exists(state_code):
candidate_queryset = candidate_queryset.filter(Q(electionStateId__iexact=state_code) |
Q(electionStateId__iexact="NA"))
vote_smart_candidate_list = list(candidate_queryset[:1])
if vote_smart_candidate_list:
vote_smart_candidate = vote_smart_candidate_list[0]
else:
vote_smart_candidate = VoteSmartCandidate()
vote_smart_candidate_id = convert_to_int(vote_smart_candidate.candidateId)
status = "RETRIEVE_VOTE_SMART_CANDIDATE_FOUND_BY_NAME"
else:
status = "RETRIEVE_VOTE_SMART_CANDIDATE_SEARCH_INDEX_MISSING"
except VoteSmartCandidate.MultipleObjectsReturned as e:
exception_multiple_object_returned = True
status = "RETRIEVE_VOTE_SMART_CANDIDATE_MULTIPLE_OBJECTS_RETURNED"
except VoteSmartCandidate.DoesNotExist:
exception_does_not_exist = True
status = "RETRIEVE_VOTE_SMART_CANDIDATE_NOT_FOUND"
results = {
'success': True if positive_value_exists(vote_smart_candidate_id) else False,
'status': status,
'error_result': error_result,
'DoesNotExist': exception_does_not_exist,
'MultipleObjectsReturned': exception_multiple_object_returned,
'vote_smart_candidate_found': True if positive_value_exists(vote_smart_candidate_id) else False,
'vote_smart_candidate_id': vote_smart_candidate_id,
'vote_smart_candidate': vote_smart_candidate,
}
return results
def candidate_politician_match_view(request):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
candidate_id = request.GET.get('candidate_id', 0)
candidate_id = convert_to_int(candidate_id)
# google_civic_election_id is included for interface usability reasons and isn't used in the processing
google_civic_election_id = request.GET.get('google_civic_election_id', 0)
google_civic_election_id = convert_to_int(google_civic_election_id)
if not positive_value_exists(candidate_id):
messages.add_message(request, messages.ERROR, "The candidate_id variable was not passed in.")
return HttpResponseRedirect(reverse('candidate:candidate_edit', args=(candidate_id,)))
candidate_campaign_manager = CandidateCampaignManager()
results = candidate_campaign_manager.retrieve_candidate_campaign_from_id(candidate_id)
if not positive_value_exists(results['candidate_campaign_found']):
messages.add_message(request, messages.ERROR,
"Candidate '{candidate_id}' not found.".format(candidate_id=candidate_id))
return HttpResponseRedirect(reverse('candidate:candidate_edit', args=(candidate_id,)))
we_vote_candidate = results['candidate_campaign']
# Make sure we have a politician for this candidate. If we don't, create a politician entry, and save the
# politician_we_vote_id in the candidate
results = candidate_politician_match(we_vote_candidate)
display_messages = True
if results['status'] and display_messages:
messages.add_message(request, messages.INFO, results['status'])
return HttpResponseRedirect(reverse('candidate:candidate_edit', args=(candidate_id,)) +
"?google_civic_election_id=" + str(google_civic_election_id))
def retrieve_contest_office(self,
contest_office_id,
contest_office_we_vote_id='',
maplight_id=None):
error_result = False
exception_does_not_exist = False
exception_multiple_object_returned = False
contest_office_on_stage = ContestOffice()
try:
if positive_value_exists(contest_office_id):
contest_office_on_stage = ContestOffice.objects.get(
id=contest_office_id)
contest_office_id = contest_office_on_stage.id
contest_office_we_vote_id = contest_office_on_stage.we_vote_id
status = "RETRIEVE_OFFICE_FOUND_BY_ID"
elif positive_value_exists(contest_office_we_vote_id):
contest_office_on_stage = ContestOffice.objects.get(
we_vote_id=contest_office_we_vote_id)
contest_office_id = contest_office_on_stage.id
contest_office_we_vote_id = contest_office_on_stage.we_vote_id
status = "RETRIEVE_OFFICE_FOUND_BY_WE_VOTE_ID"
elif positive_value_exists(maplight_id):
contest_office_on_stage = ContestOffice.objects.get(
maplight_id=maplight_id)
contest_office_id = contest_office_on_stage.id
contest_office_we_vote_id = contest_office_on_stage.we_vote_id
status = "RETRIEVE_OFFICE_FOUND_BY_MAPLIGHT_ID"
else:
status = "RETRIEVE_OFFICE_SEARCH_INDEX_MISSING"
except ContestOffice.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
exception_multiple_object_returned = True
status = "RETRIEVE_OFFICE_MULTIPLE_OBJECTS_RETURNED"
except ContestOffice.DoesNotExist:
exception_does_not_exist = True
status = "RETRIEVE_OFFICE_NOT_FOUND"
results = {
'success':
True if convert_to_int(contest_office_id) > 0 else False,
'status':
status,
'error_result':
error_result,
'DoesNotExist':
exception_does_not_exist,
'MultipleObjectsReturned':
exception_multiple_object_returned,
'contest_office_found':
True if convert_to_int(contest_office_id) > 0 else False,
'contest_office_id':
convert_to_int(contest_office_id),
'contest_office_we_vote_id':
contest_office_we_vote_id,
'contest_office':
contest_office_on_stage,
}
return results
def retrieve_candidate_campaign(
self, candidate_campaign_id, candidate_campaign_we_vote_id=None, candidate_maplight_id=None,
candidate_name=None, candidate_vote_smart_id=None):
error_result = False
exception_does_not_exist = False
exception_multiple_object_returned = False
candidate_campaign_on_stage = CandidateCampaign()
try:
if positive_value_exists(candidate_campaign_id):
candidate_campaign_on_stage = CandidateCampaign.objects.get(id=candidate_campaign_id)
candidate_campaign_id = candidate_campaign_on_stage.id
candidate_campaign_we_vote_id = candidate_campaign_on_stage.we_vote_id
status = "RETRIEVE_CANDIDATE_FOUND_BY_ID"
elif positive_value_exists(candidate_campaign_we_vote_id):
candidate_campaign_on_stage = CandidateCampaign.objects.get(we_vote_id=candidate_campaign_we_vote_id)
candidate_campaign_id = candidate_campaign_on_stage.id
candidate_campaign_we_vote_id = candidate_campaign_on_stage.we_vote_id
status = "RETRIEVE_CANDIDATE_FOUND_BY_WE_VOTE_ID"
elif positive_value_exists(candidate_maplight_id):
candidate_campaign_on_stage = CandidateCampaign.objects.get(maplight_id=candidate_maplight_id)
candidate_campaign_id = candidate_campaign_on_stage.id
candidate_campaign_we_vote_id = candidate_campaign_on_stage.we_vote_id
status = "RETRIEVE_CANDIDATE_FOUND_BY_MAPLIGHT_ID"
elif positive_value_exists(candidate_vote_smart_id):
candidate_campaign_on_stage = CandidateCampaign.objects.get(vote_smart_id=candidate_vote_smart_id)
candidate_campaign_id = candidate_campaign_on_stage.id
candidate_campaign_we_vote_id = candidate_campaign_on_stage.we_vote_id
status = "RETRIEVE_CANDIDATE_FOUND_BY_VOTE_SMART_ID"
elif positive_value_exists(candidate_name):
candidate_campaign_on_stage = CandidateCampaign.objects.get(candidate_name=candidate_name)
candidate_campaign_id = candidate_campaign_on_stage.id
candidate_campaign_we_vote_id = candidate_campaign_on_stage.we_vote_id
status = "RETRIEVE_CANDIDATE_FOUND_BY_NAME"
else:
status = "RETRIEVE_CANDIDATE_SEARCH_INDEX_MISSING"
except CandidateCampaign.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
exception_multiple_object_returned = True
status = "RETRIEVE_CANDIDATE_MULTIPLE_OBJECTS_RETURNED"
except CandidateCampaign.DoesNotExist:
exception_does_not_exist = True
status = "RETRIEVE_CANDIDATE_NOT_FOUND"
results = {
'success': True if convert_to_int(candidate_campaign_id) > 0 else False,
'status': status,
'error_result': error_result,
'DoesNotExist': exception_does_not_exist,
'MultipleObjectsReturned': exception_multiple_object_returned,
'candidate_campaign_found': True if convert_to_int(candidate_campaign_id) else False,
'candidate_campaign_id': convert_to_int(candidate_campaign_id),
'candidate_campaign_we_vote_id': candidate_campaign_we_vote_id,
'candidate_campaign': candidate_campaign_on_stage,
}
return results
def retrieve_candidate_campaign(
self, candidate_campaign_id, candidate_campaign_we_vote_id=None, candidate_maplight_id=None,
candidate_name=None, candidate_vote_smart_id=None):
error_result = False
exception_does_not_exist = False
exception_multiple_object_returned = False
candidate_campaign_on_stage = CandidateCampaign()
try:
if positive_value_exists(candidate_campaign_id):
candidate_campaign_on_stage = CandidateCampaign.objects.get(id=candidate_campaign_id)
candidate_campaign_id = candidate_campaign_on_stage.id
candidate_campaign_we_vote_id = candidate_campaign_on_stage.we_vote_id
status = "RETRIEVE_CANDIDATE_FOUND_BY_ID"
elif positive_value_exists(candidate_campaign_we_vote_id):
candidate_campaign_on_stage = CandidateCampaign.objects.get(we_vote_id=candidate_campaign_we_vote_id)
candidate_campaign_id = candidate_campaign_on_stage.id
candidate_campaign_we_vote_id = candidate_campaign_on_stage.we_vote_id
status = "RETRIEVE_CANDIDATE_FOUND_BY_WE_VOTE_ID"
elif positive_value_exists(candidate_maplight_id):
candidate_campaign_on_stage = CandidateCampaign.objects.get(maplight_id=candidate_maplight_id)
candidate_campaign_id = candidate_campaign_on_stage.id
candidate_campaign_we_vote_id = candidate_campaign_on_stage.we_vote_id
status = "RETRIEVE_CANDIDATE_FOUND_BY_MAPLIGHT_ID"
elif positive_value_exists(candidate_vote_smart_id):
candidate_campaign_on_stage = CandidateCampaign.objects.get(vote_smart_id=candidate_vote_smart_id)
candidate_campaign_id = candidate_campaign_on_stage.id
candidate_campaign_we_vote_id = candidate_campaign_on_stage.we_vote_id
status = "RETRIEVE_CANDIDATE_FOUND_BY_VOTE_SMART_ID"
elif positive_value_exists(candidate_name):
candidate_campaign_on_stage = CandidateCampaign.objects.get(candidate_name=candidate_name)
candidate_campaign_id = candidate_campaign_on_stage.id
candidate_campaign_we_vote_id = candidate_campaign_on_stage.we_vote_id
status = "RETRIEVE_CANDIDATE_FOUND_BY_NAME"
else:
status = "RETRIEVE_CANDIDATE_SEARCH_INDEX_MISSING"
except CandidateCampaign.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
exception_multiple_object_returned = True
status = "RETRIEVE_CANDIDATE_MULTIPLE_OBJECTS_RETURNED"
except CandidateCampaign.DoesNotExist:
exception_does_not_exist = True
status = "RETRIEVE_CANDIDATE_NOT_FOUND"
results = {
'success': True if convert_to_int(candidate_campaign_id) > 0 else False,
'status': status,
'error_result': error_result,
'DoesNotExist': exception_does_not_exist,
'MultipleObjectsReturned': exception_multiple_object_returned,
'candidate_campaign_found': True if convert_to_int(candidate_campaign_id) else False,
'candidate_campaign_id': convert_to_int(candidate_campaign_id),
'candidate_campaign_we_vote_id': candidate_campaign_we_vote_id,
'candidate_campaign': candidate_campaign_on_stage,
}
return results
def retrieve_vote_smart_official(
self, vote_smart_candidate_id=None, first_name=None, last_name=None, state_code=None):
"""
We want to return one and only one official
:param vote_smart_candidate_id:
:param first_name:
:param last_name:
:param state_code:
:return:
"""
error_result = False
exception_does_not_exist = False
exception_multiple_object_returned = False
vote_smart_official = VoteSmartOfficial()
try:
if positive_value_exists(vote_smart_candidate_id):
vote_smart_official = VoteSmartOfficial.objects.get(candidateId=vote_smart_candidate_id)
vote_smart_candidate_id = convert_to_int(vote_smart_official.candidateId)
status = "RETRIEVE_VOTE_SMART_OFFICIAL_FOUND_BY_ID"
elif positive_value_exists(first_name) or positive_value_exists(last_name):
official_queryset = VoteSmartOfficial.objects.all()
if positive_value_exists(first_name):
official_queryset = official_queryset.filter(firstName__istartswith=first_name)
if positive_value_exists(last_name):
official_queryset = official_queryset.filter(lastName__iexact=last_name)
if positive_value_exists(state_code):
official_queryset = official_queryset.filter(officeStateId__iexact=state_code)
vote_smart_official_list = list(official_queryset[:1])
if vote_smart_official_list:
vote_smart_official = vote_smart_official_list[0]
else:
vote_smart_official = VoteSmartOfficial()
vote_smart_candidate_id = convert_to_int(vote_smart_official.candidateId)
status = "RETRIEVE_VOTE_SMART_OFFICIAL_FOUND_BY_NAME"
else:
status = "RETRIEVE_VOTE_SMART_OFFICIAL_SEARCH_INDEX_MISSING"
except VoteSmartOfficial.MultipleObjectsReturned as e:
exception_multiple_object_returned = True
status = "RETRIEVE_VOTE_SMART_OFFICIAL_MULTIPLE_OBJECTS_RETURNED"
except VoteSmartOfficial.DoesNotExist:
exception_does_not_exist = True
status = "RETRIEVE_VOTE_SMART_OFFICIAL_NOT_FOUND"
results = {
'success': True if positive_value_exists(vote_smart_candidate_id) else False,
'status': status,
'error_result': error_result,
'DoesNotExist': exception_does_not_exist,
'MultipleObjectsReturned': exception_multiple_object_returned,
'vote_smart_official_found': True if positive_value_exists(vote_smart_candidate_id) else False,
'vote_smart_candidate_id': vote_smart_candidate_id,
'vote_smart_official': vote_smart_official,
}
return results
def organization_position_list_view(request, organization_id):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
organization_id = convert_to_int(organization_id)
google_civic_election_id = convert_to_int(request.GET.get('google_civic_election_id', 0))
organization_on_stage_found = False
try:
organization_query = Organization.objects.filter(id=organization_id)
if organization_query.count():
organization_on_stage = organization_query[0]
organization_on_stage_found = True
except Exception as e:
handle_record_not_found_exception(e, logger=logger)
organization_on_stage_found = False
if not organization_on_stage_found:
messages.add_message(request, messages.ERROR,
'Could not find organization when trying to retrieve positions.')
return HttpResponseRedirect(reverse('organization:organization_list', args=()))
else:
organization_position_list_found = False
try:
organization_position_list = PositionEntered.objects.order_by('stance')
organization_position_list = organization_position_list.filter(organization_id=organization_id)
if positive_value_exists(google_civic_election_id):
organization_position_list = organization_position_list.filter(
google_civic_election_id=google_civic_election_id)
if len(organization_position_list):
organization_position_list_found = True
except Exception as e:
handle_record_not_found_exception(e, logger=logger)
election_list = Election.objects.order_by('-election_day_text')
if organization_position_list_found:
template_values = {
'messages_on_stage': messages_on_stage,
'organization': organization_on_stage,
'organization_position_list': organization_position_list,
'election_list': election_list,
'google_civic_election_id': google_civic_election_id,
}
else:
template_values = {
'messages_on_stage': messages_on_stage,
'organization': organization_on_stage,
'election_list': election_list,
'google_civic_election_id': google_civic_election_id,
}
return render(request, 'organization/organization_position_list.html', template_values)
def office_delete_process_view(request):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
office_id = convert_to_int(request.GET.get('office_id', 0))
google_civic_election_id = convert_to_int(
request.GET.get('google_civic_election_id', 0))
office_on_stage_found = False
office_on_stage = ContestOffice()
try:
office_on_stage = ContestOffice.objects.get(id=office_id)
office_on_stage_found = True
google_civic_election_id = office_on_stage.google_civic_election_id
except ContestOffice.MultipleObjectsReturned as e:
pass
except ContestOffice.DoesNotExist:
pass
candidates_found_for_this_office = False
if office_on_stage_found:
try:
candidate_list = CandidateCampaign.objects.filter(
contest_office_id=office_id)
# if positive_value_exists(google_civic_election_id):
# candidate_list = candidate_list.filter(google_civic_election_id=google_civic_election_id)
candidate_list = candidate_list.order_by('candidate_name')
if len(candidate_list):
candidates_found_for_this_office = True
except CandidateCampaign.DoesNotExist:
pass
try:
if not candidates_found_for_this_office:
# Delete the office
office_on_stage.delete()
messages.add_message(request, messages.INFO, 'Office deleted.')
else:
messages.add_message(
request, messages.ERROR, 'Could not delete -- '
'candidates still attached to this office.')
return HttpResponseRedirect(
reverse('office:office_summary', args=(office_id, )))
except Exception as e:
messages.add_message(request, messages.ERROR,
'Could not delete office -- exception.')
return HttpResponseRedirect(
reverse('office:office_summary', args=(office_id, )))
return HttpResponseRedirect(
reverse('office:office_list', args=()) + "?google_civic_election_id=" +
str(google_civic_election_id))
def update_organization_twitter_details(self, organization, twitter_json):
"""
Update an organization entry with details retrieved from the Twitter API.
"""
success = False
status = "ENTERING_UPDATE_ORGANIZATION_TWITTER_DETAILS"
values_changed = False
if organization:
if positive_value_exists(twitter_json['id']):
if convert_to_int(twitter_json['id']) != organization.twitter_user_id:
organization.twitter_user_id = convert_to_int(twitter_json['id'])
values_changed = True
if positive_value_exists(twitter_json['screen_name']):
if twitter_json['screen_name'] != organization.organization_twitter_handle:
organization.organization_twitter_handle = twitter_json['screen_name']
values_changed = True
if positive_value_exists(twitter_json['name']):
if twitter_json['name'] != organization.twitter_name:
organization.twitter_name = twitter_json['name']
values_changed = True
if positive_value_exists(twitter_json['followers_count']):
if convert_to_int(twitter_json['followers_count']) != organization.twitter_followers_count:
organization.twitter_followers_count = convert_to_int(twitter_json['followers_count'])
values_changed = True
if positive_value_exists(twitter_json['profile_image_url_https']):
if twitter_json['profile_image_url_https'] != organization.twitter_profile_image_url_https:
organization.twitter_profile_image_url_https = twitter_json['profile_image_url_https']
values_changed = True
if positive_value_exists(twitter_json['description']):
if twitter_json['description'] != organization.twitter_description:
organization.twitter_description = twitter_json['description']
values_changed = True
if positive_value_exists(twitter_json['location']):
if twitter_json['location'] != organization.twitter_location:
organization.twitter_location = twitter_json['location']
values_changed = True
if values_changed:
organization.save()
success = True
status = "SAVED_ORG_TWITTER_DETAILS"
else:
success = True
status = "NO_CHANGES_SAVED_TO_ORG_TWITTER_DETAILS"
results = {
'success': success,
'status': status,
'organization': organization,
}
return results
def voter_guide_list_view(request):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
google_civic_election_id = convert_to_int(request.GET.get('google_civic_election_id', 0))
voter_guide_list = []
voter_guide_list_object = VoterGuideList()
if positive_value_exists(google_civic_election_id):
results = voter_guide_list_object.retrieve_voter_guides_for_election(
google_civic_election_id=google_civic_election_id)
if results['success']:
voter_guide_list = results['voter_guide_list']
else:
results = voter_guide_list_object.retrieve_all_voter_guides()
if results['success']:
voter_guide_list = results['voter_guide_list']
election_list = Election.objects.order_by('-election_day_text')
messages_on_stage = get_messages(request)
template_values = {
'election_list': election_list,
'google_civic_election_id': google_civic_election_id,
'messages_on_stage': messages_on_stage,
'voter_guide_list': voter_guide_list,
}
return render(request, 'voter_guide/voter_guide_list.html', template_values)
def candidate_list_view(request):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
google_civic_election_id = convert_to_int(request.GET.get('google_civic_election_id', 0))
candidate_list = []
try:
candidate_list = CandidateCampaign.objects.all()
if positive_value_exists(google_civic_election_id):
candidate_list = candidate_list.filter(google_civic_election_id=google_civic_election_id)
candidate_list = candidate_list.order_by('candidate_name')[:500]
except CandidateCampaign.DoesNotExist:
# This is fine, create new
pass
election_list = Election.objects.order_by('-election_day_text')
template_values = {
'messages_on_stage': messages_on_stage,
'candidate_list': candidate_list,
'election_list': election_list,
'google_civic_election_id': google_civic_election_id,
}
return render(request, 'candidate/candidate_list.html', template_values)
def quick_info_summary_view(request, quick_info_id): # TODO to be updated
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
quick_info_id = convert_to_int(quick_info_id)
quick_info_on_stage_found = False
quick_info_on_stage = QuickInfo()
try:
quick_info_on_stage = QuickInfo.objects.get(id=quick_info_id)
quick_info_on_stage_found = True
except QuickInfo.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
except QuickInfo.DoesNotExist:
# This is fine, create new
pass
if quick_info_on_stage_found:
template_values = {
'messages_on_stage': messages_on_stage,
'quick_info': quick_info_on_stage,
}
else:
template_values = {
'messages_on_stage': messages_on_stage,
}
return render(request, 'quick_info/quick_info_summary.html', template_values)
def office_list_view(request):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
google_civic_election_id = convert_to_int(request.GET.get('google_civic_election_id', 0))
office_list_manager = ContestOfficeListManager()
updated_office_list = []
results = office_list_manager.retrieve_all_offices_for_upcoming_election(google_civic_election_id, True)
if results['office_list_found']:
office_list = results['office_list_objects']
for office in office_list:
office.candidate_count = fetch_candidate_count_for_office(office.id)
updated_office_list.append(office)
election_list = Election.objects.order_by('-election_day_text')
template_values = {
'messages_on_stage': messages_on_stage,
'office_list': updated_office_list,
'election_list': election_list,
'google_civic_election_id': google_civic_election_id,
}
return render(request, 'office/office_list.html', template_values)
def office_edit_view(request, office_id):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
office_id = convert_to_int(office_id)
google_civic_election_id = request.GET.get('google_civic_election_id', 0)
office_on_stage_found = False
try:
office_on_stage = ContestOffice.objects.get(id=office_id)
office_on_stage_found = True
except ContestOffice.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
except ContestOffice.DoesNotExist:
# This is fine, create new
pass
if office_on_stage_found:
template_values = {
'messages_on_stage': messages_on_stage,
'office': office_on_stage,
'google_civic_election_id': google_civic_election_id,
}
else:
template_values = {
'messages_on_stage': messages_on_stage,
'google_civic_election_id': google_civic_election_id,
}
return render(request, 'office/office_edit.html', template_values)
def voter_summary_view(request, voter_id):
authority_required = {'admin'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
voter_id = convert_to_int(voter_id)
voter_on_stage_found = False
try:
voter_on_stage = Voter.objects.get(id=voter_id)
voter_on_stage_found = True
except Voter.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
except Voter.DoesNotExist:
# This is fine, create new
pass
if voter_on_stage_found:
template_values = {
'messages_on_stage': messages_on_stage,
'voter': voter_on_stage,
}
else:
template_values = {
'messages_on_stage': messages_on_stage,
}
return render(request, 'voter/voter_summary.html', template_values)
def election_edit_view(request, election_local_id):
authority_required = {'admin'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
election_local_id = convert_to_int(election_local_id)
election_on_stage_found = False
election_on_stage = Election()
try:
election_on_stage = Election.objects.get(id=election_local_id)
election_on_stage_found = True
except Election.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
except Election.DoesNotExist:
# This is fine, create new
pass
if election_on_stage_found:
template_values = {
'messages_on_stage': messages_on_stage,
'election': election_on_stage,
}
else:
template_values = {
'messages_on_stage': messages_on_stage,
}
return render(request, "election/election_edit.html", template_values)
def candidate_list_view(request):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
google_civic_election_id = convert_to_int(
request.GET.get('google_civic_election_id', 0))
candidate_list = []
try:
candidate_list = CandidateCampaign.objects.all()
if positive_value_exists(google_civic_election_id):
candidate_list = candidate_list.filter(
google_civic_election_id=google_civic_election_id)
candidate_list = candidate_list.order_by('candidate_name')[:500]
except CandidateCampaign.DoesNotExist:
# This is fine, create new
pass
election_list = Election.objects.order_by('-election_day_text')
template_values = {
'messages_on_stage': messages_on_stage,
'candidate_list': candidate_list,
'election_list': election_list,
'google_civic_election_id': google_civic_election_id,
}
return render(request, 'candidate/candidate_list.html', template_values)
def voter_authenticate_manually_process_view(request):
voter_api_device_id = get_voter_api_device_id(
request) # We look in the cookies for voter_api_device_id
voter_id = fetch_voter_id_from_voter_device_link(voter_api_device_id)
voter_id = convert_to_int(voter_id)
voter_signed_in = False
try:
voter_on_stage = Voter.objects.get(id=voter_id)
# If the account associated with this voter_api_device_id is an admin, complete Django authentication
if voter_on_stage.is_admin:
voter_on_stage.backend = 'django.contrib.auth.backends.ModelBackend'
login(request, voter_on_stage)
messages.add_message(request, messages.INFO, 'Voter logged in.')
voter_signed_in = True
else:
messages.add_message(request, messages.INFO,
'This account does not have Admin access.')
except Voter.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
messages.add_message(
request, messages.ERROR,
'More than one voter found. Voter not logged in.')
except Voter.DoesNotExist:
# This is fine, we will display an error
messages.add_message(request, messages.ERROR,
'Voter not found. Voter not logged in.')
if voter_signed_in:
return HttpResponseRedirect(reverse('admin_tools:admin_home', args=()))
else:
return HttpResponseRedirect(
reverse('voter:authenticate_manually', args=()))
def candidate_summary_view(request, candidate_id):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
candidate_id = convert_to_int(candidate_id)
candidate_on_stage_found = False
candidate_on_stage = CandidateCampaign()
try:
candidate_on_stage = CandidateCampaign.objects.get(id=candidate_id)
candidate_on_stage_found = True
except CandidateCampaign.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
except CandidateCampaign.DoesNotExist:
# This is fine, create new
pass
if candidate_on_stage_found:
template_values = {
'messages_on_stage': messages_on_stage,
'candidate': candidate_on_stage,
}
else:
template_values = {
'messages_on_stage': messages_on_stage,
}
return render(request, 'candidate/candidate_summary.html', template_values)
def voter_guides_import_from_master_server_view(request):
google_civic_election_id = convert_to_int(
request.GET.get('google_civic_election_id', 0))
state_code = request.GET.get('state_code', '')
results = voter_guides_import_from_master_server(request,
google_civic_election_id)
if not results['success']:
messages.add_message(request, messages.ERROR, results['status'])
else:
messages.add_message(
request, messages.INFO, 'Voter Guides import completed. '
'Saved: {saved}, Updated: {updated}, '
'Master data not imported (local duplicates found): '
'{duplicates_removed}, '
'Not processed: {not_processed}'
''.format(saved=results['saved'],
updated=results['updated'],
duplicates_removed=results['duplicates_removed'],
not_processed=results['not_processed']))
return HttpResponseRedirect(
reverse('admin_tools:sync_dashboard', args=()) +
"?google_civic_election_id=" + str(google_civic_election_id) +
"&state_code=" + str(state_code))
def measure_edit_view(request, measure_id):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
measure_id = convert_to_int(measure_id)
measure_on_stage_found = False
try:
measure_on_stage = ContestMeasure.objects.get(id=measure_id)
measure_on_stage_found = True
except ContestMeasure.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
measure_on_stage = ContestMeasure()
except ContestMeasure.DoesNotExist:
# This is fine, create new
measure_on_stage = ContestMeasure()
pass
if measure_on_stage_found:
template_values = {
'messages_on_stage': messages_on_stage,
'measure': measure_on_stage,
}
else:
template_values = {
'messages_on_stage': messages_on_stage,
}
return render(request, 'measure/measure_edit.html', template_values)
def positions_import_from_master_server_view(request):
google_civic_election_id = convert_to_int(request.GET.get('google_civic_election_id', 0))
state_code = request.GET.get('state_code', '')
if not positive_value_exists(google_civic_election_id):
messages.add_message(request, messages.INFO, 'Google civic election id is required for Positions import.')
return HttpResponseRedirect(reverse('admin_tools:sync_dashboard', args=()) + "?google_civic_election_id=" +
str(google_civic_election_id) + "&state_code=" + str(state_code))
results = positions_import_from_master_server(request, google_civic_election_id)
if not results['success']:
messages.add_message(request, messages.ERROR, results['status'])
else:
messages.add_message(request, messages.INFO, 'Positions import completed. '
'Saved: {saved}, Updated: {updated}, '
'Master data not imported (local duplicates found): '
'{duplicates_removed}, '
'Not processed: {not_processed}'
''.format(saved=results['saved'],
updated=results['updated'],
duplicates_removed=results['duplicates_removed'],
not_processed=results['not_processed']))
return HttpResponseRedirect(reverse('admin_tools:sync_dashboard', args=()) + "?google_civic_election_id=" +
str(google_civic_election_id) + "&state_code=" + str(state_code))
def voter_authenticate_manually_view(request):
messages_on_stage = get_messages(request)
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
if not positive_value_exists(voter_api_device_id):
# Create a voter_device_id and voter in the database if one doesn't exist yet
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']
voter_id = fetch_voter_id_from_voter_device_link(voter_api_device_id)
voter_id = convert_to_int(voter_id)
voter_on_stage_found = False
voter_on_stage = Voter()
try:
voter_on_stage = Voter.objects.get(id=voter_id)
voter_on_stage_found = True
except Voter.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
except Voter.DoesNotExist:
# This is fine, we will display an error
pass
if voter_on_stage_found:
set_this_voter_as_admin = "UPDATE voter_voter SET is_admin=True WHERE id={voter_id};".format(
voter_id=voter_id)
unset_this_voter_as_admin = "UPDATE voter_voter SET is_admin=False WHERE id={voter_id};".format(
voter_id=voter_id)
set_as_verified_volunteer = "UPDATE voter_voter SET is_verified_volunteer=True WHERE id={voter_id};" \
"".format(voter_id=voter_id)
unset_as_verified_volunteer = "UPDATE voter_voter SET is_verified_volunteer=False WHERE id={voter_id};" \
"".format(voter_id=voter_id)
template_values = {
'messages_on_stage': messages_on_stage,
'voter': voter_on_stage,
'voter_api_device_id': voter_api_device_id,
'is_authenticated': request.user.is_authenticated(),
'set_this_voter_as_admin': set_this_voter_as_admin,
'unset_this_voter_as_admin': unset_this_voter_as_admin,
'set_as_verified_volunteer': set_as_verified_volunteer,
'unset_as_verified_volunteer': unset_as_verified_volunteer,
}
else:
template_values = {
'messages_on_stage': messages_on_stage,
}
response = render(request, 'voter/voter_authenticate_manually.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):
# DALE 2016-02-15 Always set if we have a voter_api_device_id
if 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 candidate_retrieve_photos_view(request, candidate_id):
authority_required = {'admin'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
candidate_id = convert_to_int(candidate_id)
force_retrieve = request.GET.get('force_retrieve', 0)
candidate_campaign_manager = CandidateCampaignManager()
results = candidate_campaign_manager.retrieve_candidate_campaign_from_id(
candidate_id)
if not positive_value_exists(results['candidate_campaign_found']):
messages.add_message(
request, messages.ERROR,
"Candidate '{candidate_id}' not found.".format(
candidate_id=candidate_id))
return HttpResponseRedirect(
reverse('candidate:candidate_edit', args=(candidate_id, )))
we_vote_candidate = results['candidate_campaign']
display_messages = True
retrieve_candidate_results = retrieve_candidate_photos(
we_vote_candidate, force_retrieve)
if retrieve_candidate_results['status'] and display_messages:
messages.add_message(request, messages.INFO,
retrieve_candidate_results['status'])
return HttpResponseRedirect(
reverse('candidate:candidate_edit', args=(candidate_id, )))
def polling_location_summary_view(request, polling_location_local_id):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
polling_location_local_id = convert_to_int(polling_location_local_id)
polling_location_on_stage_found = False
polling_location_on_stage = PollingLocation()
try:
polling_location_on_stage = PollingLocation.objects.get(
id=polling_location_local_id)
polling_location_on_stage_found = True
except PollingLocation.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
except PollingLocation.DoesNotExist:
# This is fine, create new
pass
if polling_location_on_stage_found:
template_values = {
'messages_on_stage': messages_on_stage,
'polling_location': polling_location_on_stage,
}
else:
template_values = {
'messages_on_stage': messages_on_stage,
}
return render(request, 'polling_location/polling_location_summary.html',
template_values)
def positions_public_count_for_contest_measure(measure_id, measure_we_vote_id, stance_we_are_looking_for):
"""
We want to return a JSON file with the number of orgs and public figures who support
this particular measure
"""
# This implementation is built to make only two database calls. All other calculations are done here in the
# application layer
position_list_manager = PositionListManager()
all_positions_count_for_contest_measure = \
position_list_manager.retrieve_public_positions_count_for_contest_measure(
measure_id, measure_we_vote_id, stance_we_are_looking_for)
if positive_value_exists(measure_id) or positive_value_exists(measure_we_vote_id):
contest_measure_manager = ContestMeasureManager()
# Since we can take in either measure_id or measure_we_vote_id, we need to retrieve the value we don't have
if positive_value_exists(measure_id):
measure_we_vote_id = contest_measure_manager.fetch_contest_measure_we_vote_id_from_id(measure_id)
elif positive_value_exists(measure_we_vote_id):
measure_id = contest_measure_manager.fetch_contest_measure_id_from_we_vote_id(measure_we_vote_id)
json_data = {
'status': 'SUCCESSFUL_RETRIEVE_OF_PUBLIC_POSITION_COUNT_FOR_CONTEST_MEASURE',
'success': True,
'count': all_positions_count_for_contest_measure,
'ballot_item_id': convert_to_int(measure_id),
'ballot_item_we_vote_id': measure_we_vote_id,
'kind_of_ballot_item': MEASURE,
}
results = {
'json_data': json_data,
}
return results
def measure_list_view(request):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
google_civic_election_id = convert_to_int(request.GET.get('google_civic_election_id', 0))
try:
measure_list = ContestMeasure.objects.order_by('measure_title')
if positive_value_exists(google_civic_election_id):
measure_list = measure_list.filter(google_civic_election_id=google_civic_election_id)
except ContestMeasure.DoesNotExist:
# This is fine
measure_list = ContestMeasure()
pass
election_list = Election.objects.order_by('-election_day_text')
template_values = {
'messages_on_stage': messages_on_stage,
'measure_list': measure_list,
'election_list': election_list,
'google_civic_election_id': google_civic_election_id,
}
return render(request, 'measure/measure_list.html', template_values)
def fetch_next_we_vote_id_last_voter_guide_integer():
we_vote_settings_manager = WeVoteSettingsManager()
we_vote_id_last_voter_guide_integer = we_vote_settings_manager.fetch_setting('we_vote_id_last_voter_guide_integer')
we_vote_id_last_voter_guide_integer = convert_to_int(we_vote_id_last_voter_guide_integer)
we_vote_id_last_voter_guide_integer += 1
we_vote_settings_manager.save_setting('we_vote_id_last_voter_guide_integer', we_vote_id_last_voter_guide_integer)
return we_vote_id_last_voter_guide_integer
def measure_list_view(request):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
google_civic_election_id = convert_to_int(
request.GET.get('google_civic_election_id', 0))
try:
measure_list = ContestMeasure.objects.order_by('measure_title')
if positive_value_exists(google_civic_election_id):
measure_list = measure_list.filter(
google_civic_election_id=google_civic_election_id)
except ContestMeasure.DoesNotExist:
# This is fine
measure_list = ContestMeasure()
pass
election_list = Election.objects.order_by('-election_day_text')
template_values = {
'messages_on_stage': messages_on_stage,
'measure_list': measure_list,
'election_list': election_list,
'google_civic_election_id': google_civic_election_id,
}
return render(request, 'measure/measure_list.html', template_values)
def voter_guide_list_view(request):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
google_civic_election_id = convert_to_int(request.GET.get('google_civic_election_id', 0))
voter_guide_list = []
voter_guide_list_object = VoterGuideListManager()
if positive_value_exists(google_civic_election_id):
results = voter_guide_list_object.retrieve_voter_guides_for_election(
google_civic_election_id=google_civic_election_id)
if results['success']:
voter_guide_list = results['voter_guide_list']
else:
order_by = "google_civic_election_id"
results = voter_guide_list_object.retrieve_all_voter_guides(order_by)
if results['success']:
voter_guide_list = results['voter_guide_list']
election_list = Election.objects.order_by('-election_day_text')
messages_on_stage = get_messages(request)
template_values = {
'election_list': election_list,
'google_civic_election_id': google_civic_election_id,
'messages_on_stage': messages_on_stage,
'voter_guide_list': voter_guide_list,
}
return render(request, 'voter_guide/voter_guide_list.html', template_values)
def refresh_twitter_candidate_details_for_election(google_civic_election_id):
twitter_handles_added = 0
profiles_refreshed_with_twitter_data = 0
google_civic_election_id = convert_to_int(google_civic_election_id)
candidate_list_manager = CandidateCampaignListManager()
return_list_of_objects = True
candidates_results = candidate_list_manager.retrieve_all_candidates_for_upcoming_election(
google_civic_election_id, return_list_of_objects)
if candidates_results['candidate_list_found']:
candidate_list = candidates_results['candidate_list_objects']
for candidate in candidate_list:
# Extract twitter_handle from google_civic_election information
if positive_value_exists(candidate.twitter_url) \
and not positive_value_exists(candidate.candidate_twitter_handle):
# If we got a twitter_url from Google Civic, and we haven't already stored a twitter handle, move it
candidate.candidate_twitter_handle = extract_twitter_handle_from_text_string(candidate.twitter_url)
candidate.save()
twitter_handles_added += 1
if positive_value_exists(candidate.candidate_twitter_handle):
refresh_twitter_candidate_details(candidate)
profiles_refreshed_with_twitter_data += 1
status = "CANDIDATE_SOCIAL_MEDIA_RETRIEVED"
results = {
'success': True,
'status': status,
'twitter_handles_added': twitter_handles_added,
'profiles_refreshed_with_twitter_data': profiles_refreshed_with_twitter_data,
}
return results
def transfer_candidate_twitter_handles_from_google_civic(google_civic_election_id=0):
twitter_handles_transferred = 0
status = ""
google_civic_election_id = convert_to_int(google_civic_election_id)
candidate_list_object = CandidateCampaignListManager()
return_list_of_objects = True
results = candidate_list_object.retrieve_all_candidates_for_upcoming_election(google_civic_election_id,
return_list_of_objects)
status += results['status']
if results['success']:
candidate_list = results['candidate_list_objects']
else:
candidate_list = []
for candidate in candidate_list:
if not candidate.twitter_url:
continue
# Only proceed if we don't already have a twitter_handle
if not positive_value_exists(candidate.candidate_twitter_handle):
candidate.candidate_twitter_handle = candidate.twitter_url.replace("https://twitter.com/", "")
candidate.save()
twitter_handles_transferred += 1
# ######################################
# We refresh the Twitter information in another function
status += " CANDIDATE_TWITTER_HANDLES_TRANSFERRED"
results = {
'success': True,
'status': status,
'twitter_handles_transferred': twitter_handles_transferred,
}
return results
def election_edit_view(request, election_local_id):
authority_required = {'admin'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
election_local_id = convert_to_int(election_local_id)
election_on_stage_found = False
election_on_stage = Election()
try:
election_on_stage = Election.objects.get(id=election_local_id)
election_on_stage_found = True
except Election.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
except Election.DoesNotExist:
# This is fine, create new
pass
if election_on_stage_found:
template_values = {
'messages_on_stage': messages_on_stage,
'election': election_on_stage,
}
else:
template_values = {
'messages_on_stage': messages_on_stage,
}
return render(request, "election/election_edit.html", template_values)
def quick_info_summary_view(request, quick_info_id): # TODO to be updated
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
quick_info_id = convert_to_int(quick_info_id)
quick_info_on_stage_found = False
quick_info_on_stage = QuickInfo()
try:
quick_info_on_stage = QuickInfo.objects.get(id=quick_info_id)
quick_info_on_stage_found = True
except QuickInfo.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
except QuickInfo.DoesNotExist:
# This is fine, create new
pass
if quick_info_on_stage_found:
template_values = {
'messages_on_stage': messages_on_stage,
'quick_info': quick_info_on_stage,
}
else:
template_values = {
'messages_on_stage': messages_on_stage,
}
return render(request, 'quick_info/quick_info_summary.html',
template_values)
def office_edit_view(request, office_id):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
office_id = convert_to_int(office_id)
google_civic_election_id = request.GET.get('google_civic_election_id', 0)
office_on_stage_found = False
try:
office_on_stage = ContestOffice.objects.get(id=office_id)
office_on_stage_found = True
except ContestOffice.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
except ContestOffice.DoesNotExist:
# This is fine, create new
pass
if office_on_stage_found:
template_values = {
'messages_on_stage': messages_on_stage,
'office': office_on_stage,
'google_civic_election_id': google_civic_election_id,
}
else:
template_values = {
'messages_on_stage': messages_on_stage,
'google_civic_election_id': google_civic_election_id,
}
return render(request, 'office/office_edit.html', template_values)
def position_list_view(request):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
google_civic_election_id = convert_to_int(request.GET.get('google_civic_election_id', 0))
position_list_manager = PositionListManager()
if positive_value_exists(google_civic_election_id):
public_only = True
position_list = position_list_manager.retrieve_all_positions_for_election(google_civic_election_id, ANY_STANCE,
public_only)
else:
position_list = PositionEntered.objects.order_by('position_id')[:500] # This order_by is temp
election_list = Election.objects.order_by('-election_day_text')
template_values = {
'messages_on_stage': messages_on_stage,
'position_list': position_list,
'election_list': election_list,
'google_civic_election_id': google_civic_election_id,
}
return render(request, 'position/position_list.html', template_values)
def refresh_twitter_candidate_details_for_election_view(request, election_id):
authority_required = {'admin'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
google_civic_election_id = convert_to_int(election_id)
results = refresh_twitter_candidate_details_for_election(
google_civic_election_id=google_civic_election_id)
if not results['success']:
messages.add_message(request, messages.INFO, results['status'])
else:
twitter_handles_added = results['twitter_handles_added']
profiles_refreshed_with_twitter_data = results[
'profiles_refreshed_with_twitter_data']
messages.add_message(
request, messages.INFO,
"Social media retrieved. Twitter handles added: {twitter_handles_added}, "
"Profiles refreshed with Twitter data: {profiles_refreshed_with_twitter_data}"
.format(twitter_handles_added=twitter_handles_added,
profiles_refreshed_with_twitter_data=
profiles_refreshed_with_twitter_data))
return HttpResponseRedirect(
reverse('candidate:candidate_list', args=()) +
'?google_civic_election_id=' + election_id)
def voter_authenticate_manually_process_view(request):
voter_api_device_id = get_voter_api_device_id(request) # We look in the cookies for voter_api_device_id
voter_id = fetch_voter_id_from_voter_device_link(voter_api_device_id)
voter_id = convert_to_int(voter_id)
voter_signed_in = False
try:
voter_on_stage = Voter.objects.get(id=voter_id)
# If the account associated with this voter_api_device_id is an admin, complete Django authentication
if voter_on_stage.is_admin:
voter_on_stage.backend = 'django.contrib.auth.backends.ModelBackend'
login(request, voter_on_stage)
messages.add_message(request, messages.INFO, 'Voter logged in.')
voter_signed_in = True
else:
messages.add_message(request, messages.INFO, 'This account does not have Admin access.')
except Voter.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
messages.add_message(request, messages.ERROR, 'More than one voter found. Voter not logged in.')
except Voter.DoesNotExist:
# This is fine, we will display an error
messages.add_message(request, messages.ERROR, 'Voter not found. Voter not logged in.')
if voter_signed_in:
return HttpResponseRedirect(reverse('admin_tools:admin_home', args=()))
else:
return HttpResponseRedirect(reverse('voter:authenticate_manually', args=()))
def organization_edit_view(request, organization_id):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
organization_id = convert_to_int(organization_id)
organization_on_stage_found = False
try:
organization_on_stage = Organization.objects.get(id=organization_id)
organization_on_stage_found = True
except Organization.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
except Organization.DoesNotExist:
# This is fine, create new
pass
if organization_on_stage_found:
template_values = {
'messages_on_stage': messages_on_stage,
'organization': organization_on_stage,
}
else:
template_values = {
'messages_on_stage': messages_on_stage,
}
return render(request, 'organization/organization_edit.html', template_values)
def office_list_view(request):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
google_civic_election_id = convert_to_int(
request.GET.get('google_civic_election_id', 0))
office_list_manager = ContestOfficeListManager()
updated_office_list = []
results = office_list_manager.retrieve_all_offices_for_upcoming_election(
google_civic_election_id, True)
if results['office_list_found']:
office_list = results['office_list_objects']
for office in office_list:
office.candidate_count = fetch_candidate_count_for_office(
office.id)
updated_office_list.append(office)
election_list = Election.objects.order_by('-election_day_text')
template_values = {
'messages_on_stage': messages_on_stage,
'office_list': updated_office_list,
'election_list': election_list,
'google_civic_election_id': google_civic_election_id,
}
return render(request, 'office/office_list.html', template_values)
def position_edit_view(request, position_id):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
position_id = convert_to_int(position_id)
position_on_stage_found = False
try:
position_on_stage = CandidateCampaign.objects.get(id=position_id)
position_on_stage_found = True
except CandidateCampaign.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
except CandidateCampaign.DoesNotExist:
# This is fine, create new
pass
if position_on_stage_found:
template_values = {
'messages_on_stage': messages_on_stage,
'position': position_on_stage,
}
else:
template_values = {
'messages_on_stage': messages_on_stage,
}
return render(request, 'position/position_edit.html', template_values)
def admin_home_view(request):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
# Create a voter_device_id and voter in the database if one doesn't exist yet
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']
google_civic_election_id = convert_to_int(
request.GET.get('google_civic_election_id', 0))
template_values = {
'google_civic_election_id': google_civic_election_id,
}
response = render(request, 'admin_tools/index.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_summary_view(request, voter_id):
authority_required = {'admin'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
voter_id = convert_to_int(voter_id)
voter_on_stage_found = False
voter_on_stage = Voter()
try:
voter_on_stage = Voter.objects.get(id=voter_id)
voter_on_stage_found = True
except Voter.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
except Voter.DoesNotExist:
# This is fine, create new
pass
if voter_on_stage_found:
template_values = {
'messages_on_stage': messages_on_stage,
'voter': voter_on_stage,
}
else:
template_values = {
'messages_on_stage': messages_on_stage,
}
return render(request, 'voter/voter_summary.html', template_values)
def retrieve_candidate_photos_for_election_view(request, election_id):
authority_required = {'admin'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
google_civic_election_id = convert_to_int(election_id)
# We only want to process if a google_civic_election_id comes in
if not positive_value_exists(google_civic_election_id):
messages.add_message(request, messages.ERROR, "Google Civic Election ID required.")
return HttpResponseRedirect(reverse('candidate:candidate_list', args=()))
try:
candidate_list = CandidateCampaign.objects.order_by('candidate_name')
if positive_value_exists(google_civic_election_id):
candidate_list = candidate_list.filter(google_civic_election_id=google_civic_election_id)
except CandidateCampaign.DoesNotExist:
pass
display_messages = False
force_retrieve = False
# Loop through all of the candidates in this election
for we_vote_candidate in candidate_list:
retrieve_candidate_results = retrieve_candidate_photos(we_vote_candidate, force_retrieve)
if retrieve_candidate_results['status'] and display_messages:
messages.add_message(request, messages.INFO, retrieve_candidate_results['status'])
return HttpResponseRedirect(reverse('candidate:candidate_list', args=()) + "?google_civic_election_id={var}".format(
var=google_civic_election_id))
def measure_edit_view(request, measure_id):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
measure_id = convert_to_int(measure_id)
measure_on_stage_found = False
try:
measure_on_stage = ContestMeasure.objects.get(id=measure_id)
measure_on_stage_found = True
except ContestMeasure.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
measure_on_stage = ContestMeasure()
except ContestMeasure.DoesNotExist:
# This is fine, create new
measure_on_stage = ContestMeasure()
pass
if measure_on_stage_found:
template_values = {
'messages_on_stage': messages_on_stage,
'measure': measure_on_stage,
}
else:
template_values = {
'messages_on_stage': messages_on_stage,
}
return render(request, 'measure/measure_edit.html', template_values)
def quick_info_master_edit_view(request, quick_info_master_id):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
form_submitted = request.POST.get('form_submitted', False)
quick_info_master_id = convert_to_int(quick_info_master_id)
try:
quick_info_master = QuickInfoMaster.objects.get(id=quick_info_master_id)
except QuickInfoMaster.MultipleObjectsReturned as e:
# Pretty unlikely that multiple objects have the same id
messages.add_message(request, messages.ERROR, "This quick_info_master_id has multiple records.")
return HttpResponseRedirect(reverse('quick_info:quick_info_master_list', args=()))
except QuickInfoMaster.DoesNotExist:
# This is fine, create new entry
return quick_info_master_new_view(request)
if positive_value_exists(form_submitted):
# If the voter tried to submit an entry, and it didn't save, capture the changed values for display
kind_of_ballot_item = request.POST.get('kind_of_ballot_item', False)
language = request.POST.get('language', False)
info_text = request.POST.get('info_text', False)
info_html = request.POST.get('info_html', False)
master_entry_name = request.POST.get('master_entry_name', False)
more_info_credit = request.POST.get('more_info_credit', False)
more_info_url = request.POST.get('more_info_url', False)
# Write over the fields where a change has been made on the form
if kind_of_ballot_item is not False:
quick_info_master.kind_of_ballot_item = kind_of_ballot_item
if language is not False:
quick_info_master.language = language
if master_entry_name is not False:
quick_info_master.master_entry_name = master_entry_name
if more_info_credit is not False:
quick_info_master.more_info_credit = more_info_credit
if more_info_url is not False:
quick_info_master.more_info_url = more_info_url
if info_text is not False:
quick_info_master.info_text = info_text
if info_html is not False:
quick_info_master.info_html = info_html
# ##################################
# Above we have dealt with data provided by prior submit
quick_info_list = QuickInfo.objects.order_by('id') # This order_by is temp
quick_info_list = QuickInfo.objects.filter(quick_info_master_we_vote_id=quick_info_master.we_vote_id)
messages_on_stage = get_messages(request)
template_values = {
'messages_on_stage': messages_on_stage,
'ballot_item_choices': KIND_OF_BALLOT_ITEM_CHOICES,
'language_choices': LANGUAGE_CHOICES,
'quick_info_master': quick_info_master,
'quick_info_list': quick_info_list,
}
return render(request, 'quick_info/quick_info_master_edit.html', template_values)
def quick_info_master_edit_view(request, quick_info_master_id):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
form_submitted = request.POST.get('form_submitted', False)
quick_info_master_id = convert_to_int(quick_info_master_id)
try:
quick_info_master = QuickInfoMaster.objects.get(id=quick_info_master_id)
except QuickInfoMaster.MultipleObjectsReturned as e:
# Pretty unlikely that multiple objects have the same id
messages.add_message(request, messages.ERROR, "This quick_info_master_id has multiple records.")
return HttpResponseRedirect(reverse('quick_info:quick_info_master_list', args=()))
except QuickInfoMaster.DoesNotExist:
# This is fine, create new entry
return quick_info_master_new_view(request)
if positive_value_exists(form_submitted):
# If the voter tried to submit an entry, and it didn't save, capture the changed values for display
kind_of_ballot_item = request.POST.get('kind_of_ballot_item', False)
language = request.POST.get('language', False)
info_text = request.POST.get('info_text', False)
info_html = request.POST.get('info_html', False)
master_entry_name = request.POST.get('master_entry_name', False)
more_info_credit = request.POST.get('more_info_credit', False)
more_info_url = request.POST.get('more_info_url', False)
# Write over the fields where a change has been made on the form
if kind_of_ballot_item is not False:
quick_info_master.kind_of_ballot_item = kind_of_ballot_item
if language is not False:
quick_info_master.language = language
if master_entry_name is not False:
quick_info_master.master_entry_name = master_entry_name
if more_info_credit is not False:
quick_info_master.more_info_credit = more_info_credit
if more_info_url is not False:
quick_info_master.more_info_url = more_info_url
if info_text is not False:
quick_info_master.info_text = info_text
if info_html is not False:
quick_info_master.info_html = info_html
# ##################################
# Above we have dealt with data provided by prior submit
quick_info_list = QuickInfo.objects.order_by('id') # This order_by is temp
quick_info_list = QuickInfo.objects.filter(quick_info_master_we_vote_id=quick_info_master.we_vote_id)
messages_on_stage = get_messages(request)
template_values = {
'messages_on_stage': messages_on_stage,
'ballot_item_choices': KIND_OF_BALLOT_ITEM_CHOICES,
'language_choices': LANGUAGE_CHOICES,
'quick_info_master': quick_info_master,
'quick_info_list': quick_info_list,
}
return render(request, 'quick_info/quick_info_master_edit.html', template_values)
def get(self, request, format=None):
google_civic_election_id = convert_to_int(request.GET.get('google_civic_election_id', 0))
contest_office_list = ContestOffice.objects.all()
if positive_value_exists(google_civic_election_id):
contest_office_list = contest_office_list.filter(google_civic_election_id=google_civic_election_id)
serializer = ContestOfficeSerializer(contest_office_list, many=True)
return Response(serializer.data)
def office_summary_view(request, office_id):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
office_id = convert_to_int(office_id)
office_on_stage_found = False
google_civic_election_id = convert_to_int(
request.GET.get('google_civic_election_id', 0))
try:
office_on_stage = ContestOffice.objects.get(id=office_id)
office_on_stage_found = True
google_civic_election_id = office_on_stage.google_civic_election_id
except ContestOffice.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
except ContestOffice.DoesNotExist:
# This is fine, create new
pass
try:
candidate_list = CandidateCampaign.objects.filter(
contest_office_id=office_id)
if positive_value_exists(google_civic_election_id):
candidate_list = candidate_list.filter(
google_civic_election_id=google_civic_election_id)
candidate_list = candidate_list.order_by('candidate_name')
except CandidateCampaign.DoesNotExist:
# This is fine, create new
pass
election_list = Election.objects.order_by('-election_day_text')
if office_on_stage_found:
template_values = {
'messages_on_stage': messages_on_stage,
'office': office_on_stage,
'candidate_list': candidate_list,
'election_list': election_list,
'google_civic_election_id': google_civic_election_id,
}
else:
template_values = {
'messages_on_stage': messages_on_stage,
}
return render(request, 'office/office_summary.html', template_values)
def office_delete_process_view(request):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
office_id = convert_to_int(request.GET.get('office_id', 0))
google_civic_election_id = convert_to_int(request.GET.get('google_civic_election_id', 0))
office_on_stage_found = False
office_on_stage = ContestOffice()
try:
office_on_stage = ContestOffice.objects.get(id=office_id)
office_on_stage_found = True
google_civic_election_id = office_on_stage.google_civic_election_id
except ContestOffice.MultipleObjectsReturned as e:
pass
except ContestOffice.DoesNotExist:
pass
candidates_found_for_this_office = False
if office_on_stage_found:
try:
candidate_list = CandidateCampaign.objects.filter(contest_office_id=office_id)
# if positive_value_exists(google_civic_election_id):
# candidate_list = candidate_list.filter(google_civic_election_id=google_civic_election_id)
candidate_list = candidate_list.order_by('candidate_name')
if len(candidate_list):
candidates_found_for_this_office = True
except CandidateCampaign.DoesNotExist:
pass
try:
if not candidates_found_for_this_office:
# Delete the office
office_on_stage.delete()
messages.add_message(request, messages.INFO, 'Office deleted.')
else:
messages.add_message(request, messages.ERROR, 'Could not delete -- '
'candidates still attached to this office.')
return HttpResponseRedirect(reverse('office:office_summary', args=(office_id,)))
except Exception as e:
messages.add_message(request, messages.ERROR, 'Could not delete office -- exception.')
return HttpResponseRedirect(reverse('office:office_summary', args=(office_id,)))
return HttpResponseRedirect(reverse('office:office_list', args=()) +
"?google_civic_election_id=" + str(google_civic_election_id))
def voter_change_authority_process_view(request):
"""
Grant or remove an existing account volunteer or admin rights
:param request:
:return:
"""
authority_required = {'admin'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
voter_on_stage = Voter()
authority_changed = False
voter_id = request.GET.get('voter_id', 0)
voter_id = convert_to_int(voter_id)
authority_granted = request.GET.get('authority_granted', False)
authority_removed = request.GET.get('authority_removed', False)
# Check to see if this voter is already being used anywhere
voter_on_stage_found = False
try:
voter_query = Voter.objects.filter(id=voter_id)
if len(voter_query):
voter_on_stage = voter_query[0]
voter_on_stage_found = True
except Exception as e:
handle_record_not_found_exception(e, logger=logger)
if voter_on_stage_found:
try:
if authority_granted == 'verified_volunteer':
voter_on_stage.is_verified_volunteer = True
authority_changed = True
elif authority_granted == 'admin':
voter_on_stage.is_admin = True
authority_changed = True
if authority_removed == 'verified_volunteer':
voter_on_stage.is_verified_volunteer = False
authority_changed = True
elif authority_removed == 'admin':
voter_on_stage.is_admin = False
authority_changed = True
if authority_changed:
voter_on_stage.save()
messages.add_message(request, messages.INFO,
'Voter authority updated.')
except Exception as e:
handle_record_not_saved_exception(e, logger=logger)
messages.add_message(request, messages.ERROR,
'Could not save voter.')
else:
messages.add_message(request, messages.ERROR,
'Could not save change to authority.')
return HttpResponseRedirect(reverse('voter:voter_edit', args=(voter_id, )))
def politician_list_view(request):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
state_code = request.GET.get('state_code', '')
politician_search = request.GET.get('politician_search', '')
google_civic_election_id = convert_to_int(
request.GET.get('google_civic_election_id', 0))
politician_list = []
try:
politician_list = Politician.objects.all()
if positive_value_exists(state_code):
politician_list = politician_list.filter(state_code=state_code)
filters = []
if positive_value_exists(politician_search):
new_filter = Q(politician_name__icontains=politician_search)
filters.append(new_filter)
new_filter = Q(
politician_twitter_handle__icontains=politician_search)
filters.append(new_filter)
new_filter = Q(political_party__icontains=politician_search)
filters.append(new_filter)
new_filter = Q(we_vote_id__icontains=politician_search)
filters.append(new_filter)
# Add the first query
if len(filters):
final_filters = filters.pop()
# ...and "OR" the remaining items in the list
for item in filters:
final_filters |= item
politician_list = politician_list.filter(final_filters)
politician_list = politician_list.order_by('politician_name')[:200]
except ObjectDoesNotExist:
# This is fine, create new
pass
election_list = Election.objects.order_by('-election_day_text')
template_values = {
'messages_on_stage': messages_on_stage,
'google_civic_election_id': google_civic_election_id,
'politician_list': politician_list,
'politician_search': politician_search,
'election_list': election_list,
'state_code': state_code,
}
return render(request, 'politician/politician_list.html', template_values)
def special_interest_group_rating_list_view(request, special_interest_group_id):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
special_interest_group_id = convert_to_int(special_interest_group_id)
# google_civic_election_id = request.GET.get('google_civic_election_id', 0)
special_interest_group = VoteSmartSpecialInterestGroup()
special_interest_group_found = False
try:
special_interest_group_query = VoteSmartSpecialInterestGroup.objects.filter(sigId=special_interest_group_id)
if special_interest_group_query.count():
special_interest_group = special_interest_group_query[0]
special_interest_group_found = True
except VotesmartApiError as error_instance:
# Catch the error message coming back from Vote Smart and pass it in the status
error_message = error_instance.args
status = "EXCEPTION_RAISED: {error_message}".format(error_message=error_message)
print_to_log(logger=logger, exception_message_optional=status)
special_interest_group_found = False
if not special_interest_group_found:
messages.add_message(request, messages.ERROR,
'Could not find special_interest_group when trying to retrieve ratings.')
return HttpResponseRedirect(reverse('import_export_vote_smart:vote_smart_special_interest_group_list', args=()))
else:
rating_list = []
rating_list_found = False
try:
rating_list = VoteSmartRatingOneCandidate.objects.order_by('-timeSpan')
rating_list = rating_list.filter(sigId=special_interest_group_id)
if len(rating_list):
rating_list_found = True
except VotesmartApiError as error_instance:
# Catch the error message coming back from Vote Smart and pass it in the status
error_message = error_instance.args
status = "EXCEPTION_RAISED: {error_message}".format(error_message=error_message)
print_to_log(logger=logger, exception_message_optional=status)
# election_list = Election.objects.order_by('-election_day_text')
if rating_list_found:
template_values = {
'messages_on_stage': messages_on_stage,
'special_interest_group': special_interest_group,
'rating_list': rating_list,
# 'election_list': election_list,
# 'google_civic_election_id': google_civic_election_id,
}
else:
template_values = {
'messages_on_stage': messages_on_stage,
'special_interest_group': special_interest_group,
# 'election_list': election_list,
# 'google_civic_election_id': google_civic_election_id,
}
return render(request, 'import_export_vote_smart/group_rating_list.html', template_values)
def candidate_edit_view(request, candidate_id):
authority_required = {'verified_volunteer'} # admin, verified_volunteer
if not voter_has_authority(request, authority_required):
return redirect_to_sign_in_page(request, authority_required)
messages_on_stage = get_messages(request)
candidate_id = convert_to_int(candidate_id)
candidate_on_stage_found = False
candidate_on_stage = CandidateCampaign()
try:
candidate_on_stage = CandidateCampaign.objects.get(id=candidate_id)
candidate_on_stage_found = True
except CandidateCampaign.MultipleObjectsReturned as e:
handle_record_found_more_than_one_exception(e, logger=logger)
except CandidateCampaign.DoesNotExist:
# This is fine, create new
pass
if candidate_on_stage_found:
# Working with Vote Smart data
try:
vote_smart_candidate_id = candidate_on_stage.vote_smart_id
rating_list_query = VoteSmartRatingOneCandidate.objects.order_by(
'-timeSpan') # Desc order
rating_list = rating_list_query.filter(
candidateId=vote_smart_candidate_id)
except VotesmartApiError as error_instance:
# Catch the error message coming back from Vote Smart and pass it in the status
error_message = error_instance.args
status = "EXCEPTION_RAISED: {error_message}".format(
error_message=error_message)
print_to_log(logger=logger, exception_message_optional=status)
rating_list = []
# Working with We Vote Positions
try:
candidate_position_list = PositionEntered.objects.order_by(
'stance')
candidate_position_list = candidate_position_list.filter(
candidate_campaign_id=candidate_id)
# if positive_value_exists(google_civic_election_id):
# organization_position_list = candidate_position_list.filter(
# google_civic_election_id=google_civic_election_id)
except Exception as e:
handle_record_not_found_exception(e, logger=logger)
candidate_position_list = []
template_values = {
'messages_on_stage': messages_on_stage,
'candidate': candidate_on_stage,
'rating_list': rating_list,
'candidate_position_list': candidate_position_list,
}
else:
template_values = {
'messages_on_stage': messages_on_stage,
}
return render(request, 'candidate/candidate_edit.html', template_values)