def bookmark_search_page(request):
bookmarks = EmptyQuerySet()
search_type = ''
query = ''
show_results = False
if request.GET.has_key('search_type') and request.GET.has_key('query'):
search_type = request.GET['search_type']
query = request.GET['query'].strip()
show_results = True
form = BookmarkSearchForm({'search_type':search_type,'query':query})
if search_type and query:
if search_type =='tag':
bookmarks = Bookmark.objects.filter(tag__name__icontains = query)
elif search_type == 'user':
bookmarks = Bookmark.objects.filter(user__username__icontains = query)
elif search_type == 'bookmark':
bookmarks = Bookmark.objects.filter(title__icontains = query)
else:
pass
if request.user.username:
bookmarks = bookmarks.filter(Q(user = request.user)|Q(shared = True))
else:
bookmarks = bookmarks.filter(shared = True)
else:
form = BookmarkSearchForm()
return render_to_response(
'bookmark_search_page.html',
context_instance = RequestContext(request,{
'search_type':search_type,
'query':query,
'form':form,
'show_user':True,
'bookmark_list':bookmarks,
'paginate_by' : ITEMS_PER_PAGE,
'show_results' : show_results,
})
)
def needed_ballot_positions(doc, active_positions):
'''Returns text answering the question "what does this document
need to pass?". The return value is only useful if the document
is currently in IESG evaluation.'''
yes = [p for p in active_positions if p and p.pos_id == "yes"]
noobj = [p for p in active_positions if p and p.pos_id == "noobj"]
blocking = [p for p in active_positions if p and p.pos.blocking]
recuse = [p for p in active_positions if p and p.pos_id == "recuse"]
answer = []
if len(yes) < 1:
answer.append("Needs a YES.")
if blocking:
if len(blocking) == 1:
answer.append("Has a %s." % blocking[0].pos.name.upper())
else:
if blocking[0].pos.name.upper().endswith('S'):
answer.append("Has %d %ses." % (len(blocking), blocking[0].pos.name.upper()))
else:
answer.append("Has %d %ss." % (len(blocking), blocking[0].pos.name.upper()))
needed = 1
if doc.type_id == "draft" and doc.intended_std_level_id in ("bcp", "ps", "ds", "std"):
needed = two_thirds_rule(recused=len(recuse))
elif doc.type_id == "statchg":
if isinstance(doc,Document):
related_set = doc.relateddocument_set
elif isinstance(doc,DocHistory):
related_set = doc.relateddochistory_set
else:
related_set = EmptyQuerySet()
for rel in related_set.filter(relationship__slug__in=['tops', 'tois', 'tohist', 'toinf', 'tobcp', 'toexp']):
if (rel.target.document.std_level.slug in ['bcp','ps','ds','std']) or (rel.relationship.slug in ['tops','tois','tobcp']):
needed = two_thirds_rule(recused=len(recuse))
break
else:
if len(yes) < 1:
return " ".join(answer)
have = len(yes) + len(noobj)
if have < needed:
more = needed - have
if more == 1:
answer.append("Needs one more YES or NO OBJECTION position to pass.")
else:
answer.append("Needs %d more YES or NO OBJECTION positions to pass." % more)
else:
if blocking:
answer.append("Has enough positions to pass once %s positions are resolved." % blocking[0].pos.name.upper())
else:
answer.append("Has enough positions to pass.")
return " ".join(answer)
def render(self, context):
try:
object = template.resolve_variable(self.object, context)
except template.VariableDoesNotExist:
return ''
# extract all news
# if obect is a Person, extract news related to all current and past charges
if isinstance(object, Person):
news = EmptyQuerySet()
for c in object.all_institution_charges:
news |= c.related_news
elif isinstance(object, basestring):
if object == 'politicians_all':
news = EmptyQuerySet()
for c in InstitutionCharge.objects.all():
news |= c.related_news
if object == 'politicians_council':
news = EmptyQuerySet()
for c in municipality.council.charges:
news |= c.related_news
if object == 'politicians_gov':
news = EmptyQuerySet()
for c in municipality.gov.charges:
news |= c.related_news
else:
news = object.related_news
# filter only news of a given type (INST or COMM) (if given)
if self.news_type:
news = news.filter(news_type=self.news_type)
# sort news by news_date, descending order
# context[self.context_var] = sorted(news, key=lambda n: n.news_date or datetime.date(datetime.MINYEAR,1,1), reverse=True)[0:15]
context[self.context_var] = news.order_by("-created")[0:15]
return ''
def render(self, context):
try:
object = template.resolve_variable(self.object, context)
except template.VariableDoesNotExist:
return ''
# extract all news
# if obect is a Person, extract news related to all current and past charges
if isinstance(object, Person):
news = EmptyQuerySet()
for c in object.all_institution_charges:
news |= c.related_news
elif isinstance(object, basestring):
if object == 'politicians_all':
news = EmptyQuerySet()
for c in InstitutionCharge.objects.all():
news |= c.related_news
if object == 'politicians_council':
news = EmptyQuerySet()
for c in municipality.council.charges:
news |= c.related_news
if object == 'politicians_gov':
news = EmptyQuerySet()
for c in municipality.gov.charges:
news |= c.related_news
else:
news = object.related_news
# filter only news of a given type (INST or COMM) (if given)
if self.news_type:
news = news.filter(news_type=self.news_type)
# sort news by news_date, descending order
context[self.context_var] = sorted(news, key=lambda n: n.news_date, reverse=True)[0:15]
return ''
def voters_email(request, election, poll=None, voter_uuid=None):
user = request.admin
TEMPLATES = [
('vote', _('Time to Vote')),
('info', _('Additional Info')),
]
default_template = 'vote'
if not election.any_poll_feature_can_send_voter_mail:
raise PermissionDenied('34')
if not election.any_poll_feature_can_send_voter_booth_invitation:
TEMPLATES.pop(0)
default_template = 'info'
if election.voting_extended_until and not election.voting_ended_at:
TEMPLATES.append(('extension', _('Voting end date extended')))
template = request.REQUEST.get('template', default_template)
if not template in [t[0] for t in TEMPLATES]:
raise Exception("bad template")
polls = [poll]
if not poll:
polls = election.polls_by_link_id
voter = None
if voter_uuid:
try:
if poll:
voter = get_object_or_404(Voter, uuid=voter_uuid, poll=poll)
else:
voter = get_object_or_404(Voter,
uuid=voter_uuid,
election=election)
except Voter.DoesNotExist:
raise PermissionDenied('35')
if not voter:
url = election_reverse(election, 'index')
return HttpResponseRedirect(url)
election_url = election.get_absolute_url()
default_subject = render_to_string('email/%s_subject.txt' % template,
{'custom_subject': "<SUBJECT>"})
default_body = render_to_string(
'email/%s_body.txt' % template, {
'election': election,
'election_url': election_url,
'custom_subject': default_subject,
'custom_message': '<BODY>',
'voter': {
'vote_hash': '<SMART_TRACKER>',
'name': '<VOTER_NAME>',
'voter_name': '<VOTER_NAME>',
'voter_surname': '<VOTER_SURNAME>',
'voter_login_id': '<VOTER_LOGIN_ID>',
'voter_password': '******',
'audit_passwords': '1',
'get_audit_passwords': ['pass1', 'pass2', '...'],
'get_quick_login_url': '<VOTER_LOGIN_URL>',
'poll': poll,
'election': election
}
})
q_param = request.GET.get('q', None)
filtered_voters = election.voters.filter()
if poll:
filtered_voters = poll.voters.filter()
if not q_param:
filtered_voters = EmptyQuerySet()
else:
voters_filters = get_filters(q_param, VOTER_TABLE_HEADERS,
VOTER_SEARCH_FIELDS, VOTER_BOOL_KEYS_MAP,
VOTER_EXTRA_HEADERS)
filtered_voters = filtered_voters.filter(voters_filters)
if not filtered_voters.count():
message = _("No voters were found.")
messages.error(request, message)
url = election_reverse(election, 'polls_list')
return HttpResponseRedirect(url)
if request.method == "GET":
email_form = EmailVotersForm()
email_form.fields['subject'].initial = dict(TEMPLATES)[template]
if voter:
email_form.fields['send_to'].widget = \
email_form.fields['send_to'].hidden_widget()
else:
email_form = EmailVotersForm(request.POST)
if email_form.is_valid():
# the client knows to submit only once with a specific voter_id
voter_constraints_include = None
voter_constraints_exclude = None
update_booth_invitation_date = False
if template == 'vote':
update_booth_invitation_date = True
if voter:
voter_constraints_include = {'uuid': voter.uuid}
# exclude those who have not voted
if email_form.cleaned_data['send_to'] == 'voted':
voter_constraints_exclude = {'vote_hash': None}
# include only those who have not voted
if email_form.cleaned_data['send_to'] == 'not-voted':
voter_constraints_include = {'vote_hash': None}
for _poll in polls:
if not _poll.feature_can_send_voter_mail:
continue
if template == 'vote' and not \
_poll.feature_can_send_voter_booth_invitation:
continue
subject_template = 'email/%s_subject.txt' % template
body_template = 'email/%s_body.txt' % template
extra_vars = {
'custom_subject': email_form.cleaned_data['subject'],
'custom_message': email_form.cleaned_data['body'],
'election_url': election_url,
}
task_kwargs = {
'subject_template': subject_template,
'body_template': body_template,
'extra_vars': extra_vars,
'voter_constraints_include': voter_constraints_include,
'voter_constraints_exclude': voter_constraints_exclude,
'update_date': True,
'update_booth_invitation_date':
update_booth_invitation_date,
'q_param': q_param,
}
log_obj = election
if poll:
log_obj = poll
if voter:
log_obj.logger.info(
"Notifying single voter %s, [template: %s, filter: %s]",
voter.voter_login_id, template, q_param)
else:
log_obj.logger.info(
"Notifying voters, [template: %s, filter: %r]",
template, q_param)
tasks.voters_email.delay(_poll.pk, **task_kwargs)
filters = get_voters_filters_with_constraints(
q_param, voter_constraints_include, voter_constraints_exclude)
send_to = filtered_voters.filter(filters)
if q_param and not send_to.filter(filters).count():
msg = "No voters matched your filters. No emails were sent."
messages.error(request, _(msg))
else:
messages.info(request, _("Email sending started"))
url = election_reverse(election, 'polls_list')
if poll:
url = poll_reverse(poll, 'voters')
if q_param:
url += '?q=%s' % urllib.quote_plus(q_param)
return HttpResponseRedirect(url)
context = {
'email_form': email_form,
'election': election,
'poll': poll,
'voter_o': voter,
'default_subject': default_subject,
'default_body': default_body,
'template': template,
'filtered_voters': filtered_voters,
'templates': TEMPLATES
}
set_menu('voters', context)
if not poll:
set_menu('polls', context)
return render_template(request, "voters_email", context)
def voters_email(request, election, poll=None, voter_uuid=None):
user = request.admin
TEMPLATES = [
('vote', _('Time to Vote')),
('info', _('Additional Info')),
]
default_template = 'vote'
if not election.any_poll_feature_can_send_voter_mail:
raise PermissionDenied('34')
if not election.any_poll_feature_can_send_voter_booth_invitation:
TEMPLATES.pop(0)
default_template = 'info'
if election.voting_extended_until and not election.voting_ended_at:
TEMPLATES.append(('extension', _('Voting end date extended')))
template = request.REQUEST.get('template', default_template)
if not template in [t[0] for t in TEMPLATES]:
raise Exception("bad template")
polls = [poll]
if not poll:
polls = election.polls_by_link_id
voter = None
if voter_uuid:
try:
if poll:
voter = get_object_or_404(Voter, uuid=voter_uuid, poll=poll)
else:
voter = get_object_or_404(Voter, uuid=voter_uuid,
election=election)
except Voter.DoesNotExist:
raise PermissionDenied('35')
if not voter:
url = election_reverse(election, 'index')
return HttpResponseRedirect(url)
election_url = election.get_absolute_url()
default_subject = render_to_string(
'email/%s_subject.txt' % template, {
'custom_subject': "<SUBJECT>"
})
default_body = render_to_string(
'email/%s_body.txt' % template, {
'election' : election,
'election_url' : election_url,
'custom_subject' : default_subject,
'custom_message': '<BODY>',
'voter': {
'vote_hash' : '<SMART_TRACKER>',
'name': '<VOTER_NAME>',
'voter_name': '<VOTER_NAME>',
'voter_surname': '<VOTER_SURNAME>',
'voter_login_id': '<VOTER_LOGIN_ID>',
'voter_password': '******',
'audit_passwords': '1',
'get_audit_passwords': ['pass1', 'pass2', '...'],
'get_quick_login_url': '<VOTER_LOGIN_URL>',
'poll': poll,
'election' : election}
})
q_param = request.GET.get('q', None)
filtered_voters = election.voters.filter()
if poll:
filtered_voters = poll.voters.filter()
if not q_param:
filtered_voters = EmptyQuerySet()
else:
voters_filters = get_filters(q_param, VOTER_TABLE_HEADERS,
VOTER_SEARCH_FIELDS,
VOTER_BOOL_KEYS_MAP,
VOTER_EXTRA_HEADERS)
filtered_voters = filtered_voters.filter(voters_filters)
if not filtered_voters.count():
message = _("No voters were found.")
messages.error(request, message)
url = election_reverse(election, 'polls_list')
return HttpResponseRedirect(url)
if request.method == "GET":
email_form = EmailVotersForm()
email_form.fields['subject'].initial = dict(TEMPLATES)[template]
if voter:
email_form.fields['send_to'].widget = \
email_form.fields['send_to'].hidden_widget()
else:
email_form = EmailVotersForm(request.POST)
if email_form.is_valid():
# the client knows to submit only once with a specific voter_id
voter_constraints_include = None
voter_constraints_exclude = None
update_booth_invitation_date = False
if template == 'vote':
update_booth_invitation_date = True
if voter:
voter_constraints_include = {'uuid': voter.uuid}
# exclude those who have not voted
if email_form.cleaned_data['send_to'] == 'voted':
voter_constraints_exclude = {'vote_hash' : None}
# include only those who have not voted
if email_form.cleaned_data['send_to'] == 'not-voted':
voter_constraints_include = {'vote_hash': None}
for _poll in polls:
if not _poll.feature_can_send_voter_mail:
continue
if template == 'vote' and not \
_poll.feature_can_send_voter_booth_invitation:
continue
subject_template = 'email/%s_subject.txt' % template
body_template = 'email/%s_body.txt' % template
extra_vars = {
'custom_subject' : email_form.cleaned_data['subject'],
'custom_message' : email_form.cleaned_data['body'],
'election_url' : election_url,
}
task_kwargs = {
'subject_template': subject_template,
'body_template': body_template,
'extra_vars': extra_vars,
'voter_constraints_include': voter_constraints_include,
'voter_constraints_exclude': voter_constraints_exclude,
'update_date': True,
'update_booth_invitation_date': update_booth_invitation_date,
'q_param': q_param,
}
log_obj = election
if poll:
log_obj = poll
if voter:
log_obj.logger.info("Notifying single voter %s, [template: %s, filter: %s]",
voter.voter_login_id, template, q_param)
else:
log_obj.logger.info("Notifying voters, [template: %s, filter: %r]", template, q_param)
tasks.voters_email.delay(_poll.pk, **task_kwargs)
filters = get_voters_filters_with_constraints(q_param,
voter_constraints_include, voter_constraints_exclude)
send_to = filtered_voters.filter(filters)
if q_param and not send_to.filter(filters).count():
msg = "No voters matched your filters. No emails were sent."
messages.error(request, _(msg))
else:
messages.info(request, _("Email sending started"))
url = election_reverse(election, 'polls_list')
if poll:
url = poll_reverse(poll, 'voters')
if q_param:
url += '?q=%s' % urllib.quote_plus(q_param)
return HttpResponseRedirect(url)
context = {
'email_form': email_form,
'election': election,
'poll': poll,
'voter_o': voter,
'default_subject': default_subject,
'default_body': default_body,
'template': template,
'filtered_voters': filtered_voters,
'templates': TEMPLATES
}
set_menu('voters', context)
if not poll:
set_menu('polls', context)
return render_template(request, "voters_email", context)
def reporting(request):
local_timezone = pytz.timezone(TIME_ZONE)
# load/set defaults
start_date = request.GET.get('start_date')
end_date = request.GET.get('end_date')
signup_start_date = request.GET.get('signup_start_date')
signup_end_date = request.GET.get('signup_end_date')
order_start_date = request.GET.get('order_start_date')
order_end_date = request.GET.get('order_end_date')
# Convert strings to local timezone datetimes
start_date, end_date, desc = fix_date_range(start_date, end_date)
signup_start_date, signup_end_date, signup_desc = fix_date_range(signup_start_date, signup_end_date)
order_start_date, order_end_date, order_desc = fix_date_range(order_start_date, order_end_date)
buyers_all = Buyer.objects.all()
buyers_active = Buyer.objects.filter(
userprofile__site=request.user.userprofile.site,
userprofile__approved=True,
)
vendors_all = Vendor.objects.all()
vendors_active = Vendor.objects.filter(
userprofile__site=request.user.userprofile.site,
userprofile__approved=True,
)
report = request.GET.get('report')
# initialize data
orders = []
output = []
output_text = ''
csv_text = ''
table_text = ''
filter = []
filter2= []
totals = []
report_header = ''
column_headers = []
column_fields = []
data = ''
if report in ['buyer_all', 'vendor_all']:
if report == 'buyer_all':
as_buyer = True
else:
as_buyer = False
# Build report data
if as_buyer:
query = buyers_all
report_header = 'Buyers - All %s' % ', '.join(filter)
column_headers = ['Buyer', 'Username', 'Signup Date']
else:
query = vendors_all
report_header = 'Vendors - All %s' % ', '.join(filter)
column_headers = ['Vendor', 'Username', 'Signup Date']
query, filter = apply_report_filters(request, query)
data = query
# obj = Buyer or Vendor
column_fields = ['obj.name', 'obj.userprofile.user.username', 'obj.created.strftime("%m-%d-%Y")']
filter = []
elif report in ['new_buyer_no_purchases', 'buyer_inactive', 'new_vendor_no_sales', 'vendor_inactive']:
if report in ['new_buyer_no_purchases', 'buyer_inactive']:
as_buyer = True
else:
as_buyer = False
company_orders = []
company_no_orders = []
if as_buyer:
query = buyers_all
else:
query = vendors_all
query, filter = apply_report_filters(request, query)
for company in query:
if as_buyer:
try:
orders = Order.objects.filter(buyer = company.userprofile.user, state=COMPLETED)
except:
orders = EmptyQuerySet()
else:
try:
orders = Order.objects.filter(vendor = company, state=COMPLETED)
except:
orders = EmptyQuerySet()
orders, filter2 = apply_order_filters(request, orders)
num_orders = len(orders)
if num_orders == 0:
company_no_orders.append(company)
else:
company_orders.append(company)
if filter2:
filter += filter2
if as_buyer:
if report in ['new_buyer_no_purchases']:
report_header = 'New Buyers - No Purchases - %s' % ', '.join(filter)
else:
report_header = 'Inactive Buyers - No Purchases - %s' % ', '.join(filter)
column_headers = ['Buyer', 'Username', 'Signup Date']
else:
if report in ['new_buyer_no_purchases']:
report_header = 'New Vendors - No Sales - %s' % ', '.join(filter)
else:
report_header = 'Inactive Vendors - No Sales- %s' % ', '.join(filter)
column_headers = ['Vendor', 'Username', 'Signup Date']
# Build report data
data = company_no_orders
# obj = Buyer
column_fields = ['obj.name', 'obj.userprofile.user.username', 'obj.created.strftime("%m-%d-%Y")']
if report in ['new_buyer_no_purchases', 'new_vendor_no_sales']:
filter = ['signup_date']
else:
filter = ['signup_date', 'order_date']
elif report in ['buyer_search', 'vendor_search']:
if report in ['buyer_search']:
as_buyer = True
else:
as_buyer = False
company_no_orders = []
company_orders = []
if as_buyer:
query = buyers_all
else:
query = vendors_all
query, filter = apply_report_filters(request, query)
# Build report data
data = query
if as_buyer:
report_header = 'Buyer Search - %s' % ', '.join(filter)
column_headers = ['Buyer', 'Username', 'Created', 'City', 'State', 'Zip']
else:
report_header = 'Vendor Search - %s' % ', '.join(filter)
column_headers = ['Vendor', 'Username', 'Created', 'City', 'State', 'Zip']
# obj = Buyer or Vendor
column_fields = ['obj.name', 'obj.userprofile.user.username', 'obj.created.strftime("%m-%d-%Y")', 'obj.city', 'obj.state', 'obj.zip']
filter = ['signup_date', 'location', 'username']
elif report in ['order_summary_by_buyer']:
if report == 'order_summary_by_buyer':
as_buyer = True
else:
as_buyer = False
data = []
if as_buyer:
query= buyers_all
else:
query= vendors_all
query, filter = apply_report_filters(request, query)
for company in query:
min = 9999999
max = 0
count = 0
total = 0
avg = 0
min_date = datetime(3000,1,1).replace(tzinfo=utc)
max_date = datetime(2000,1,1).replace(tzinfo=utc)
if as_buyer:
try:
orders = Order.objects.filter(buyer=company.userprofile.user)
except:
orders = EmptyQuerySet()
else:
try:
orders = Order.objects.filter(vendor=company)
except:
orders = EmptyQuerySet()
orders = orders.filter(state=COMPLETED, date_confirmed__isnull=False)
orders, filter2 = apply_order_filters(request, orders)
if orders:
for o in orders:
o_total = o.total # cache so we don't have to keep re-calling this VERY expensive @property
count += 1
total += o_total
if o_total < min:
min = o_total
if o_total > max:
max = o_total
if o.date_confirmed < min_date:
min_date = o.date_confirmed
if o.date_confirmed > max_date:
max_date = o.date_confirmed
avg = round(total / count, 2)
# Can't do these without an actual order total db field
# count = orders.aggregate(Count('order_total'))['order_total__count']
# total = orders.aggregate(Sum('order_total'))['order_total__sum']
# avg = orders.aggregate(Avg('order_total'))['order_total__avg']
# min = orders.aggregate(Min('order_total'))['order_total__min']
# max = orders.aggregate(Max('order_total'))['order_total__max']
# min_date = orders.aggregate(Min('date_confirmed'))['date_confirmed__min']
# max_date = orders.aggregate(Max('date_confirmed'))['date_confirmed__max']
if count:
data.append({
'company' : company,
'total' : total,
'count' : count,
'avg' : avg,
'min' : min,
'max' : max,
'min_date' : min_date,
'max_date' : max_date,
})
filter += filter2 # add report and order filter descriptions
report_header = 'Order Summary by %s - %s' % ('Buyer' if as_buyer else 'Vendor', ', '.join(filter))
column_headers = [
'Buyer' if as_buyer else 'Vendor',
'Username',
'Created',
'First Order',
'Last Order'
'# Orders',
'Total $',
'Avg $',
'Min $',
'Max $',
]
# obj = Vendor
column_fields = [
"obj['company'].name",
"obj['company'].userprofile.user.username",
"obj['company'].created.strftime('%m-%d-%Y')",
"obj['min_date'].strftime('%m-%d-%Y')",
"obj['max_date'].strftime('%m-%d-%Y')",
"obj['count']",
"obj['total']",
"obj['avg']",
"obj['min']",
"obj['max']",
]
filter = ['order_date', 'buyer', 'location', 'username', 'note_slow']
elif report in ['order_details_by_buyer', 'order_details_by_vendor']:
if report == 'order_details_by_buyer':
as_buyer = True
else:
as_buyer = False
data = []
if as_buyer:
query= buyers_all
else:
query= vendors_all
query, filter = apply_report_filters(request, query)
for company in query:
min = 9999999
max = 0
count = 0
total = 0
avg = 0
min_date = datetime(3000,1,1).replace(tzinfo=utc)
max_date = datetime(2000,1,1).replace(tzinfo=utc)
if as_buyer:
try:
orders = Order.objects.filter(buyer=company.userprofile.user)
except:
orders = EmptyQuerySet()
else:
try:
orders = Order.objects.filter(vendor=company)
except:
orders = EmptyQuerySet()
orders = orders.filter(state=COMPLETED, date_confirmed__isnull=False)
orders, filter2 = apply_order_filters(request, orders)
if orders:
for o in orders:
data.append(o)
filter += filter2 # add report and order filter descriptions
report_header = 'Order Details by %s - %s' % ('Buyer' if as_buyer else 'Vendor', ', '.join(filter))
column_headers = [
'Buyer' if as_buyer else 'Vendor',
'Vendor' if as_buyer else 'Buyer',
'Order',
'Subtotal',
'Shipping',
'Total',
'Confirmed',
'Delivery Type',
'Delivery Date',
'Ratings',
'# Items',
'Categories/#',
]
# obj = Vendor
column_fields = [
"obj.buyer.userprofile.buyer.name" if as_buyer else "obj.vendor.name",
"obj.vendor.name" if as_buyer else "obj.buyer.userprofile.buyer.name",
"obj.uniqueId",
"obj.sub_total",
"obj.shipping",
"obj.total",
"obj.date_confirmed.replace(tzinfo=local_timezone).strftime('%m-%d-%Y %H:%M')",
"DELIVERY_OPTION_DICT[obj.delivery_option]",
"obj.delivery_date.strftime('%m-%d-%Y') if obj.delivery_date else ''",
"'%s / %s' % (obj.buyer_rating, obj.vendor_rating)" if as_buyer else "'%s / %s' % (obj.vendor_rating, obj.buyer_rating)",
"obj.entry_set.count()",
"obj.categories_count",
]
filter = ['signup_date', 'order_date', 'buyer', 'vendor', 'location', 'note_slow']
else:
# Report not found
pass
#################################
# Process the report
#################################
# process the report if one is specified
if data and report:
csv_text = data_as_csv(data, report_header, column_headers, column_fields)
table_text = data_as_table(data, report_header, column_headers, column_fields)
if (request.GET.get('csv')):
filename = "%s-%s.csv" % (request.site.name, report)
response = HttpResponse(
csv_text,
mimetype = 'text/csv;',
)
response['Content-Disposition'] = 'attachment;filename=%s' % (filename)
return response
context = {
# "start_date" : start_date.astimezone(pytz.timezone('US/Eastern')),
# "end_date" : end_date.astimezone(pytz.timezone('US/Eastern')),
# "signup_start_date" : signup_start_date.astimezone(pytz.timezone('US/Eastern')),
# "signup_end_date" : signup_end_date.astimezone(pytz.timezone('US/Eastern')),
# "order_start_date" : order_start_date.astimezone(pytz.timezone('US/Eastern')),
# "order_end_date" : order_end_date.astimezone(pytz.timezone('US/Eastern')),
# "reports" : reports,
"report" : report,
"buyers_active" : buyers_active,
"vendors_active" : vendors_active,
"orders" : orders,
"data" : data,
"output" : output,
"output_text" : table_text,
"output_rows" : len(data),
"csv_url" : "%s?%s&csv=1" % (request.path, request.META.get('QUERY_STRING')),
"filter" : filter,
"date_ranges" : DATE_RANGES,
# "output_text" : csv_text,
}
return render_to_response(
"reporting.html",
context,
context_instance = RequestContext(request)
)
def voters_email(request, election, poll=None, voter_uuid=None):
user = request.admin
TEMPLATES = [("vote", _("Time to Vote")), ("info", _("Additional Info"))]
default_template = "vote"
if not election.any_poll_feature_can_send_voter_mail:
raise PermissionDenied("34")
if not election.any_poll_feature_can_send_voter_booth_invitation:
TEMPLATES.pop(0)
default_template = "info"
if election.voting_extended_until and not election.voting_ended_at:
TEMPLATES.append(("extension", _("Voting end date extended")))
template = request.REQUEST.get("template", default_template)
if not template in [t[0] for t in TEMPLATES]:
raise Exception("bad template")
polls = [poll]
if not poll:
polls = election.polls_by_link_id
voter = None
if voter_uuid:
try:
if poll:
voter = get_object_or_404(Voter, uuid=voter_uuid, poll=poll)
else:
voter = get_object_or_404(Voter, uuid=voter_uuid, election=election)
except Voter.DoesNotExist:
raise PermissionDenied("35")
if not voter:
url = election_reverse(election, "index")
return HttpResponseRedirect(url)
election_url = election.get_absolute_url()
default_subject = render_to_string("email/%s_subject.txt" % template, {"custom_subject": "<SUBJECT>"})
default_body = render_to_string(
"email/%s_body.txt" % template,
{
"election": election,
"election_url": election_url,
"custom_subject": default_subject,
"custom_message": "<BODY>",
"voter": {
"vote_hash": "<SMART_TRACKER>",
"name": "<VOTER_NAME>",
"voter_name": "<VOTER_NAME>",
"voter_surname": "<VOTER_SURNAME>",
"voter_login_id": "<VOTER_LOGIN_ID>",
"voter_password": "******",
"audit_passwords": "1",
"get_audit_passwords": ["pass1", "pass2", "..."],
"get_quick_login_url": "<VOTER_LOGIN_URL>",
"poll": poll,
"election": election,
},
},
)
q_param = request.GET.get("q", None)
filtered_voters = election.voters.filter()
if poll:
filtered_voters = poll.voters.filter()
if not q_param:
filtered_voters = EmptyQuerySet()
else:
voters_filters = get_filters(
q_param, VOTER_TABLE_HEADERS, VOTER_SEARCH_FIELDS, VOTER_BOOL_KEYS_MAP, VOTER_EXTRA_HEADERS
)
filtered_voters = filtered_voters.filter(voters_filters)
if not filtered_voters.count():
message = _("No voters were found.")
messages.error(request, message)
url = election_reverse(election, "polls_list")
return HttpResponseRedirect(url)
if request.method == "GET":
email_form = EmailVotersForm()
email_form.fields["subject"].initial = dict(TEMPLATES)[template]
if voter:
email_form.fields["send_to"].widget = email_form.fields["send_to"].hidden_widget()
else:
email_form = EmailVotersForm(request.POST)
if email_form.is_valid():
# the client knows to submit only once with a specific voter_id
voter_constraints_include = None
voter_constraints_exclude = None
update_booth_invitation_date = False
if template == "vote":
update_booth_invitation_date = True
if voter:
voter_constraints_include = {"uuid": voter.uuid}
# exclude those who have not voted
if email_form.cleaned_data["send_to"] == "voted":
voter_constraints_exclude = {"vote_hash": None}
# include only those who have not voted
if email_form.cleaned_data["send_to"] == "not-voted":
voter_constraints_include = {"vote_hash": None}
for _poll in polls:
if not _poll.feature_can_send_voter_mail:
continue
if template == "vote" and not _poll.feature_can_send_voter_booth_invitation:
continue
subject_template = "email/%s_subject.txt" % template
body_template = "email/%s_body.txt" % template
extra_vars = {
"custom_subject": email_form.cleaned_data["subject"],
"custom_message": email_form.cleaned_data["body"],
"election_url": election_url,
}
task_kwargs = {
"subject_template": subject_template,
"body_template": body_template,
"extra_vars": extra_vars,
"voter_constraints_include": voter_constraints_include,
"voter_constraints_exclude": voter_constraints_exclude,
"update_date": True,
"update_booth_invitation_date": update_booth_invitation_date,
"q_param": q_param,
}
log_obj = election
if poll:
log_obj = poll
if voter:
log_obj.logger.info(
"Notifying single voter %s, [template: %s, filter: %s]", voter.voter_login_id, template, q_param
)
else:
log_obj.logger.info("Notifying voters, [template: %s, filter: %r]", template, q_param)
tasks.voters_email.delay(_poll.pk, **task_kwargs)
filters = get_voters_filters_with_constraints(q_param, voter_constraints_include, voter_constraints_exclude)
send_to = filtered_voters.filter(filters)
if q_param and not send_to.filter(filters).count():
msg = "No voters matched your filters. No emails were sent."
messages.error(request, _(msg))
else:
messages.info(request, _("Email sending started"))
url = election_reverse(election, "polls_list")
if poll:
url = poll_reverse(poll, "voters")
if q_param:
url += "?q=%s" % urllib.quote_plus(q_param)
return HttpResponseRedirect(url)
context = {
"email_form": email_form,
"election": election,
"poll": poll,
"voter_o": voter,
"default_subject": default_subject,
"default_body": default_body,
"template": template,
"filtered_voters": filtered_voters,
"templates": TEMPLATES,
}
set_menu("voters", context)
if not poll:
set_menu("polls", context)
return render_template(request, "voters_email", context)
