def test_sold_market_flyer_date(self):
""" Assert when the next_flyer_date() is sold out, the user can not
select the date to purchase flyers on the sold out date.
"""
count = 1
while count <= 10:
slot = Slot(site_id=2,
business_id=count,
renewal_rate=99,
is_autorenew=True,
end_date=datetime.date.today() + datetime.timedelta(
days=count))
slot.save()
flyer_placement = FlyerPlacement(
site_id=2,
slot=slot,
send_date=next_flyer_date())
flyer_placement.save()
count += 1
self.prep_for_flyer_purchase()
response = self.client.get(reverse('add-flyer-dates',
args=[self.slot.id]))
self.assertContains(response, 'disabled="disabled" type="checkbox" ' +
'name="%s" value="%s" id="id_%s" /><span class="light">' % (
(str(date_filter(next_flyer_date(), "F j")),
str(next_flyer_date()),
str(date_filter(next_flyer_date(), "F j")))))
def __init__(self, available_flyer_dates_list,
subdivision_consumer_count=None, checked_data=None, *args, **kwargs):
""" Dynamically create 10 sets of location fields. """
super(AddFlyerDatesForm, self).__init__(*args, **kwargs)
if checked_data:
self.fields['subdivision_consumer_count'].initial = \
checked_data.get('subdivision_consumer_count', 0)
else:
self.fields['subdivision_consumer_count'].initial = \
subdivision_consumer_count
for flyer_month in available_flyer_dates_list:
for week in flyer_month['weeks']:
attrs = {'value': week['send_date']}
if not week['date_is_available']:
attrs['disabled'] = 'disabled'
if checked_data:
if '%s' % date_filter(week['send_date'], 'F j'
) in checked_data:
attrs['checked'] = 'checked'
else:
if week['checked'] and week['date_is_available']:
attrs['checked'] = 'checked'
self.fields['%s' % date_filter(
week['send_date'], 'F j')] = forms.ChoiceField(
widget=CheckboxInput(
attrs=attrs,
check_test=True),
initial=week['send_date'],
label = '%s' % date_filter(week['send_date'], 'F j'),
required=False)
def common_flyer_purchase_asserts(self, response, first_purchase_date,
second_purchase_date):
""" Make assertions common to displaying results of flyer purchase. """
self.assertContains(response, 'Email Flyer scheduled for %s.' %
date_filter(first_purchase_date, "M j, Y"))
self.assertContains(response, 'Email Flyer scheduled for %s.' %
date_filter(second_purchase_date, "M j, Y"))
def nettes_datum(value, short=False):
try:
tzinfo = getattr(value, 'tzinfo', None)
value = datetime.date(value.year, value.month, value.day)
except AttributeError:
# Passed value wasn't a date object
return value
except ValueError:
# Date arguments out of range
return value
today = datetime.datetime.now(tzinfo).date()
delta = value - today
datum = maybe_year
if delta.days == 0:
if short:
return "heute"
return mark_safe( "heute" + grey_span( ", " + datum(value, today) ) )
if delta.days == 1:
if short:
return "morgen"
return mark_safe( "morgen" + grey_span( ", " + datum(value, today) ) )
if delta.days == -1:
if short:
return "gestern"
return mark_safe( "gestern" + grey_span( ", " + datum(value, today) ) )
if 1 < delta.days < 7:
if short:
return date_filter(value, "l")
return mark_safe( date_filter(value, "l") + grey_span( ", " + datum(value, today) ) )
if short:
return date_filter(value, "D") + ", " + datum(value, today)
return date_filter(value, "l") + ", " + datum(value, today)
def __unicode__(self):
date_format = u'l, %s' % ugettext("DATE_FORMAT")
return ugettext('%(title)s: %(start)s-%(end)s') % {
'title': unicode(self.event),
'start': date_filter(self.start, date_format),
'end': date_filter(self.end, date_format),
}
def nettes_datum(value, short=False):
try:
tzinfo = getattr(value, "tzinfo", None)
value = datetime.date(value.year, value.month, value.day)
except AttributeError:
# Passed value wasn't a date object
return value
except ValueError:
# Date arguments out of range
return value
today = datetime.datetime.now(tzinfo).date()
delta = value - today
datum = maybe_year
if delta.days == 0:
if short:
return "heute"
return mark_safe("heute" + grey_span(", " + datum(value, today)))
if delta.days == 1:
if short:
return "morgen"
return mark_safe("morgen" + grey_span(", " + datum(value, today)))
if delta.days == -1:
if short:
return "gestern"
return mark_safe("gestern" + grey_span(", " + datum(value, today)))
if 1 < delta.days < 7:
if short:
return date_filter(value, "l")
return mark_safe(
date_filter(value, "l") + grey_span(", " + datum(value, today)))
if short:
return date_filter(value, "D") + ", " + datum(value, today)
return date_filter(value, "l") + ", " + datum(value, today)
def track(request, start_date=None, end_date=None):
if (start_date and end_date) and (start_date != end_date):
start = datetime.strptime(start_date, '%Y-%m-%d')
end = datetime.strptime(end_date, '%Y-%m-%d')
position_list = PositionReport.objects.filter(
timestamp_received__gt=start,
timestamp_received__lt=end,
source__display_on_maps=True).order_by('-timestamp_received')
map_info_string = 'Showing the positions received from %s to %s' % (
date_filter(start), date_filter(end))
elif (start_date and not end_date) or ((start_date == end_date)
and start_date):
start = datetime.strptime(start_date, '%Y-%m-%d')
end = start + timedelta(days=1)
position_list = PositionReport.objects.filter(
timestamp_received__gt=start,
timestamp_received__lt=end,
source__display_on_maps=True).order_by('-timestamp_received')
map_info_string = 'Showing the positions received %s' % date_filter(
start)
else:
position_list = PositionReport.objects.filter(
source__display_on_maps=True).order_by(
'-timestamp_received')[:NON_DATE_REPORT_LIMIT]
map_info_string = 'Showing the last %s positions received' % NON_DATE_REPORT_LIMIT
return render_to_response(
'largemap.html', {
'map_info': map_info_string,
'positions': position_list,
'google_maps_api_key': getattr(settings, 'GOOGLE_MAPS_KEY',
'not-set'),
},
context_instance=RequestContext(request))
def dates_display(self) -> str:
two_months = self.start_date.month != self.end_date.month
if two_months:
return "{0} - {1}".format(date_filter(self.start_date, "F j"),
date_filter(self.end_date, "F j, Y"))
else:
return "{0}-{1}".format(date_filter(self.start_date, "F j"),
date_filter(self.end_date, "j, Y"))
def hide_time_if_zero(dt):
# Only show hours/minutes if they have been specified
if dt.tzinfo:
localtime = dt.astimezone(get_current_timezone())
else:
localtime = dt
if localtime.hour == 0 and localtime.minute == 0:
return date_filter(localtime, settings.DATE_FORMAT)
return date_filter(localtime, settings.DATETIME_FORMAT)
def hide_time_if_zero(dt):
# Only show hours/minutes if they have been specified
if dt.tzinfo:
localtime = dt.astimezone(get_current_timezone())
else:
localtime = dt
if localtime.hour == 0 and localtime.minute == 0:
return date_filter(localtime, settings.DATE_FORMAT)
return date_filter(localtime, settings.DATETIME_FORMAT)
def test_aff_site_from_launch(self):#
""" Assert we can post to the page to view the From Launch report. """
affiliate_partner = MediaPartner.objects.get(id=401)
self.login(affiliate_partner.email)
site = Site.objects.get(id=2)
launch_date = site.launch_date
inception = 'From Launch Date (' + date_filter(launch_date, 'F') + ' ' \
+ date_filter(launch_date, 'Y') + ')'
response = self.client.post('/hudson-valley/media-partner/',
{'report':inception})
self.assertEqual(response.status_code, 200)
def callback_time_string(self):
if not self.requires_action_at:
return None
end_time = self.requires_action_at + datetime.timedelta(minutes=30)
if self.callback_window_type == CALLBACK_WINDOW_TYPES.HALF_HOUR_WINDOW:
return u"{start} - {end}".format(
start=date_filter(localtime(self.requires_action_at), "g:iA"),
end=date_filter(localtime(end_time), "g:iA"),
)
else:
return date_filter(localtime(self.requires_action_at), "g:iA")
def __unicode__(self):
date_format = u'l, %s' % ugettext("DATE_FORMAT")
result = ugettext('%(title)s: %(start)s-%(end)s') % {
'title': unicode(self.event),
'start': date_filter(self.start, date_format),
'end': date_filter(self.end, date_format),
}
if self.rule:
result += " repeating %s until %s" % (self.rule, date_filter(self.repeat_until, date_format))
return result
def __unicode__(self):
date_format = u'l, %s' % ugettext("DATE_FORMAT")
result = ugettext('%(title)s: %(start)s-%(end)s') % {
'title': unicode(self.event),
'start': date_filter(self.start, date_format),
'end': date_filter(self.end, date_format),
}
if self.rule:
result += " repeating %s until %s" % (
self.rule, date_filter(self.repeat_until, date_format))
return result
def create_products_list(request, site=None):
""" Return a list of tuples of all products to be purchased """
flyer_dates_list, add_slot_choice, add_annual_slot_choice = \
get_selected_product(request)
product_list = []
if not site:
site = get_current_site(request)
if flyer_dates_list is not None:
# Product for Flyers.
pre_description = 'Email Flyer scheduled for '
locked_flyer_price = request.session['locked_flyer_price']
product_1_base_days = get_product_from_cache(1).base_days
for flyer_date in flyer_dates_list:
flyer_date = dateutil.parser.parse(flyer_date)
product_list.append((1, locked_flyer_price,
'%s%s.' % (pre_description, date_filter(flyer_date, "M j, Y")),
flyer_date,
flyer_date + datetime.timedelta(days=product_1_base_days)))
elif add_slot_choice is not None:
# Purchasing a Slot and Maybe a few Flyers
try:
slot_price = get_product_price(2, site)
except KeyError:
slot_price = get_locked_data(request, site)[0]
slot_start_datetime = datetime.datetime.now()
slot_start_date = date_filter(slot_start_datetime, "m/d/y")
slot_end_date = datetime.date.today() + \
dateutil.relativedelta.relativedelta(months=1)
slot_end_datetime = datetime.datetime.combine(slot_end_date,
datetime.time())
slot_description = \
'Monthly 10Coupon Publishing Plan: %s - %s.' % (
slot_start_date, date_filter(slot_end_date, "m/d/y"))
product_list = [(2, slot_price, slot_description, slot_start_datetime,
slot_end_datetime)]
elif add_annual_slot_choice is not None:
slot_annual_start_datetime = datetime.datetime.now()
slot_annual_start_date = date_filter(
slot_annual_start_datetime, "m/d/y")
slot_annual_end_date = datetime.date.today() + \
dateutil.relativedelta.relativedelta(months=12)
slot_annual_end_datetime = datetime.datetime.combine(
slot_annual_end_date, datetime.time())
slot_annual_description = \
'Annual 10Coupon Publishing Plan: %s - %s.' % (
slot_annual_start_date, date_filter(
slot_annual_end_date, "m/d/y"))
product_list = [(3, get_product_price(3, site),
slot_annual_description, slot_annual_start_datetime,
slot_annual_end_datetime)]
return product_list
def table_waybills(request, queryset=ets.models.Waybill.objects.all(), filtering=None):
"""Ajax view that returns list of waybills for using in datatables"""
search_string = request.GET.get("search_string", "")
request_params = {}
if search_string:
request_params["search_string"] = search_string
queryset = queryset.filter(pk__icontains=search_string)
column_index_map = {
0: 'order__pk',
1: 'pk',
2: 'order__warehouse__name',
3: 'order__consignee__name',
4: 'order__location__name',
5: 'destination__name',
6: 'transaction_type',
7: 'transport_dispach_signed_date',
8: 'receipt_signed_date',
9: 'pk',
10: 'pk',
11: 'pk',
}
params = { 'filtering': filtering } if filtering else None
redirect_url = get_api_url(request, column_index_map, "api_waybills", params, request_params )
if redirect_url:
return HttpResponse(simplejson.dumps({'redirect_url': redirect_url}), content_type="application/json; charset=utf-8")
return get_datatables_records(request, queryset, column_index_map, lambda item: [
fill_link(item.order.get_absolute_url(), item.order.pk),
fill_link(item.get_absolute_url(), item.pk),
item.order.warehouse.name,
item.order.consignee.name,
item.order.location.name,
item.destination.name if item.destination else "",
item.get_transaction_type_display(),
item.transport_dispach_signed_date and date_filter(item.transport_dispach_signed_date).upper() \
or fill_link(item.get_absolute_url(), _("Open")),
item.receipt_signed_date and date_filter(item.receipt_signed_date).upper() \
or fill_link(reverse('waybill_reception', kwargs={'waybill_pk': item.pk})
if item.has_receive_permission(request.user) else '', _("Receive")),
"%s/%s" % (item.validated and "D" or "-", item.receipt_validated and "R" or "-", ),
"%s/%s" % (item.sent_compas and "D" or "-", item.receipt_sent_compas and "R" or "-", ),
fill_link(reverse('waybill_delete', kwargs={'waybill_pk': item.pk}) \
if item.has_delete_permission(request.user) else '',
_("Delete"), "delete_waybill"),
])
def _format_year_wise_date(value, same_year_format: str,
different_year_format: str):
date_format = None
if isinstance(value, date): # `datetime` objects are also `date` objects
date_format = same_year_format if value.year == timezone.localdate(
).year else different_year_format
return date_filter(value, date_format)
def items(self, obj):
until = timezone.now().today()
since = until - dt.timedelta(days=7)
queryset = (Article.objects.published().filter(
date__date__gte=since, date__date__lt=until).order_by("-date"))
items = {}
for article in queryset:
date = article.date
modified = article.modified_at
entry = items.setdefault(
date.date(),
{
"title":
"Daily Digest for {}".format(date_filter(date, "jS F Y")),
"date":
date,
"modified":
modified,
"link":
obj["link"][:-1] + reverse("digest", args=(date, )),
"objects": [],
},
)
entry["objects"].append(article)
entry["modified"] = max(entry["modified"], modified)
return items.values()
def notify_users_shift_change(sender, instance, **kwargs):
shift = instance
if shift.pk:
old_shift = Shift.objects.get(pk=shift.pk)
if old_shift.starting_time >= datetime.now() and times_changed(
shift, old_shift):
subject = u'Schicht wurde verändert: {task} am {date}'.format(
task=old_shift.task.name,
date=date_filter(old_shift.starting_time))
message = render_to_string('shift_modification_notification.html',
dict(old=old_shift, shift=shift))
from_email = "Volunteer-Planner.org <*****@*****.**>"
addresses = shift.helpers.values_list('user__email', flat=True)
if addresses:
mail = EmailMessage(subject=subject,
body=message,
to=['*****@*****.**'],
from_email=from_email,
bcc=addresses)
logger.info(
u'Shift %s at %s changed: (%s-%s -> %s->%s). Sending email notification to %d affected user(s).',
shift.task.name, shift.facility.name,
old_shift.starting_time, old_shift.ending_time,
shift.starting_time, shift.ending_time, len(addresses))
mail.send()
def test_aff_site_current_month(self):#
""" Assert we can post to the page to view the Current Month report."""
affiliate_partner = MediaPartner.objects.get(id=401)
self.login(affiliate_partner.email)
today = datetime.today()
payment = Payment.objects.get(id=401)
payment.create_datetime = today
payment.save()
media_pie_share = MediaPieShare.objects.get(id=2)
media_pie_share.start_date = today.date()
media_pie_share.save()
current_month = 'Current Month (' + date_filter(today, 'F') + ' ' + \
date_filter(today, 'Y') + ')'
response = self.client.post('/hudson-valley/media-partner/',
{'report':current_month})
self.assertEqual(response.status_code, 200)
def smartdate(value, arg):
rendered = date_filter(value, arg)
if 'c' in arg:
rendered = re.sub(
'(a|p)\.m\.c', lambda m: '%sm' % m.group(1), rendered)
rendered = re.sub('(A|P)Mc', lambda m: '%s.M.' % m.group(1), rendered)
return rendered
def get_event_email_data(event, email_type):
e, v = event, event.venue
d = dict(
email_type=email_type,
event_id=e.pk,
event__title=e.title,
event__event_url=e.get_absolute_url(force_hostname=True),
event__tweet_count=e.tweet_count,
event__short_url=e.get_short_url(),
event__ticket_url=e.ticket_or_tm_url,
event__event_date=e.event_date,
event__event_start_time=e.event_start_time,
event__event_timezone=e.event_timezone,
event__venue__name=v.name,
event__venue__address=v.address,
event__venue__citystatezip=v.citystatezip,
event__venue__map_url=v.map_url,
)
d['event__event_date'] = date_filter(d['event__event_date'], "l, N j, Y")
if d['event__event_start_time']:
d['event__event_start_time'] = time_filter(d['event__event_start_time'])
if e.show_checkins:
d['fsq_checkins'] = v.fsq_checkins
d['fsq_ratio'] = v.fsq_ratio_display
return d
def test_dates(self):
self.assertLess(settings.DATES_VIDE_GRENIER['open'], settings.DATES_VIDE_GRENIER['close'])
self.assertLess(settings.DATES_VIDE_GRENIER['close'], settings.DATES_VIDE_GRENIER['event'])
for status in ['open', 'close', 'event']:
self.assertIn(
date_filter(settings.DATES_VIDE_GRENIER[status], 'j F o'),
self.client.get(reverse('videgrenier:home')).content.decode())
def test_update_details(self, logged_in_client, update_stub):
# Arrange
# Act
resp = logged_in_client.get(update_stub["url"])
# Assert
assert resp.context["supply_chain_name"] == update_stub["sc_name"]
assert resp.context["completion_estimation"] == date_filter(
datetime.strptime(update_stub["sa_completion"], r"%Y-%m-%d"),
"j F Y")
assert (resp.context["update"].implementation_rag_rating ==
update_stub["sau_rag"])
assert resp.context["update"].reason_for_delays == update_stub[
"sau_reason"]
assert resp.context["update"].submission_date.strftime(
r"%d.%m.%Y") == date_filter(date.today(), "d.m.Y")
def notify_users_shift_change(sender, instance, **kwargs):
shift = instance
if shift.pk:
old_shift = Shift.objects.get(pk=shift.pk)
if old_shift.starting_time >= datetime.now() and times_changed(shift,
old_shift):
subject = u'Schicht wurde verändert: {task} am {date}'.format(
task=old_shift.task.name,
date=date_filter(old_shift.starting_time))
message = render_to_string('shift_modification_notification.html',
dict(old=old_shift, shift=shift))
from_email = "Volunteer-Planner.org <*****@*****.**>"
addresses = shift.helpers.values_list('user__email', flat=True)
if addresses:
mail = EmailMessage(subject=subject,
body=message,
to=['*****@*****.**'],
from_email=from_email,
bcc=addresses)
logger.info(
u'Shift %s at %s changed: (%s-%s -> %s->%s). Sending email notification to %d affected user(s).',
shift.task.name, shift.facility.name,
old_shift.starting_time, old_shift.ending_time,
shift.starting_time, shift.ending_time,
len(addresses))
mail.send()
def get_event_email_data(event, email_type):
e, v = event, event.venue
d = dict(
email_type=email_type,
event_id=e.pk,
event__title=e.title,
event__event_url=e.get_absolute_url(force_hostname=True),
event__tweet_count=e.tweet_count,
event__short_url=e.get_short_url(),
event__ticket_url=e.ticket_or_tm_url,
event__event_date=e.event_date,
event__event_start_time=e.event_start_time,
event__event_timezone=e.event_timezone,
event__venue__name=v.name,
event__venue__address=v.address,
event__venue__citystatezip=v.citystatezip,
event__venue__map_url=v.map_url,
)
d['event__event_date'] = date_filter(d['event__event_date'], "l, N j, Y")
if d['event__event_start_time']:
d['event__event_start_time'] = time_filter(
d['event__event_start_time'])
if e.show_checkins:
d['fsq_checkins'] = v.fsq_checkins
d['fsq_ratio'] = v.fsq_ratio_display
return d
def date_format(value, arg):
if value is None:
return ''
if isinstance(value, date):
return date_filter(value, arg=arg)
return str(value)
def _render_pdf(pdf, params):
kw = {
'url': pdf.file.url,
'title': pdf.title,
'size': pdf.size,
'date': date_filter(pdf.date, 'N jS, Y'),
}
return PDF_TAG % kw
def prepare(self, request):
""" Prepare the context dict for this request. """
ad_rep = AdRep.objects.get(email=request.session['consumer']['email'])
# Note: the resultant string itself has an embedded %s.
link_base = '%s%s' % (ad_rep.site.domain, reverse('redirect-for-ad-rep',
kwargs={'redirect_string': '%s' + ad_rep.url},
urlconf='urls_local.urls_1'))
# Remove / before redirect_string.
link_base = link_base.replace('/%s', '%s')
LOG.debug('link_base: %s' % link_base)
my_commisions = AdRepCompensation.current_pay_period.filter(
ad_rep=ad_rep, child_ad_rep=None).aggregate(
Sum('amount'))['amount__sum']
if not my_commisions:
my_commisions = 0
my_teams_commisions = AdRepCompensation.current_pay_period.filter(
ad_rep=ad_rep).exclude(child_ad_rep=None).aggregate(
Sum('amount'))['amount__sum']
if not my_teams_commisions:
my_teams_commisions = 0
total_commisions_ever = ad_rep.ad_rep_compensations.aggregate(
Sum('amount'))['amount__sum']
(start_of_pay_period, end_of_pay_period) = get_current_pay_period_dates()
pay_period = '%s %s - %s %s' % (date_filter(start_of_pay_period, 'F'),
date_filter(start_of_pay_period, 'd'),
date_filter(end_of_pay_period, 'F'),
date_filter(end_of_pay_period, 'd'),)
if not total_commisions_ever:
total_commisions_ever = 0
self.context.update({'ad_rep':ad_rep,
'is_ad_rep_account': 1,
'pay_period': pay_period,
'my_commisions': '$' '%.2f' % my_commisions,
'my_teams_commisions': '$' '%.2f' % my_teams_commisions,
'total_earnings_this_pay_period': '$' '%.2f' % (
my_commisions + my_teams_commisions),
'total_commisions_ever': '$' '%.2f' % total_commisions_ever,
'how_it_works_link': link_base % reverse('how-it-works',
urlconf='urls_local.urls_1'),
'recommend_enrollment_link':
link_base % reverse('recommend-enroll',
urlconf='urls_local.urls_1'),
'personal_website_link': '%s/%s/' % (ad_rep.site.domain,
ad_rep.url) })
return ad_rep
def __str__(self):
return "{}: {} {} {} {} {}".format(
self.id,
date_filter(self.datetime),
self.liters,
_("l"),
self.mileage,
_("km"),
)
def live_unread_notification_list(request):
''' Return a json with a unread notification list '''
try:
user_is_authenticated = request.user.is_authenticated()
except TypeError: # Django >= 1.11
user_is_authenticated = request.user.is_authenticated
if not user_is_authenticated:
data = {'unread_count': 0, 'unread_list': []}
return JsonResponse(data)
try:
# If they don't specify, make it 5.
num_to_fetch = request.GET.get('max', 5)
num_to_fetch = int(num_to_fetch)
# if num_to_fetch is negative, force at least one fetched notifications
num_to_fetch = max(1, num_to_fetch)
# put a sane ceiling on the number retrievable
num_to_fetch = min(num_to_fetch, 100)
except ValueError:
num_to_fetch = 5 # If casting to an int fails, just make it 5.
try:
fetch_start_index = int(request.GET.get('start', 0))
except ValueError:
fetch_start_index = 0
unread_list = []
notifications = _get_unread_notificatons(request)
for notification in notifications[fetch_start_index:num_to_fetch +
fetch_start_index]:
struct = model_to_dict(notification)
timestamp_display = date_filter(
localtime(notification.timestamp),
dj_settings.SHORT_DATETIME_FORMAT,
)
struct['timestamp_display'] = timestamp_display
struct['slug'] = id2slug(notification.id)
if notification.actor:
struct['actor'] = str(notification.actor)
if notification.target:
struct['target'] = str(notification.target)
if notification.action_object:
struct['action_object'] = str(notification.action_object)
if notification.data:
struct['data'] = notification.data
unread_list.append(struct)
if request.GET.get('mark_as_read'):
notification.mark_as_read()
data = {
'unread_count': request.user.notifications.unread().count(),
'unread_list': unread_list
}
return JsonResponse(data)
def test_post_add_flyer_dates(self):
""" Assert when a logged in advertiser selects dates from the
flyer-by-date page, they get pushed to the ecommerce page with the
appropriate order items in the order summary display."""
self.prep_for_flyer_purchase()
first_purchase_date = next_flyer_date() + datetime.timedelta(days=14)
second_purchase_date = next_flyer_date() + datetime.timedelta(days=28)
first_purchase_date_key = date_filter(first_purchase_date, "F j")
second_purchase_date_key = date_filter(second_purchase_date, "F j")
kwargs = {
str(first_purchase_date_key): str(first_purchase_date),
str(second_purchase_date_key): str(second_purchase_date),
'subdivision_consumer_count': 100}
response = self.client.post(reverse('add-flyer-dates',
args=[self.slot.id]), kwargs, follow=True)
self.assertTemplateUsed(response,
'ecommerce/display_checkout_coupon_purchase.html')
self.common_flyer_purchase_asserts(response, first_purchase_date,
second_purchase_date)
def _add_xlsx_title(self, sheet, title, width):
"""Добавляет заголовок в документы xlsx.
Args:
sheet - таблица с отчетом
title - название отчета
widw - число ячеек под заголовок
Returns: None
"""
sheet.insert_rows(1)
sheet.merge_cells(start_row=1,
start_column=1,
end_row=1,
end_column=width)
cell = sheet.cell(row=1, column=1)
cell.value = title
cell.font = Font(size=12, bold=True, italic=True)
sheet.insert_rows(2)
sheet.merge_cells(start_row=2,
start_column=1,
end_row=2,
end_column=width)
sheet.insert_rows(3)
sheet.merge_cells(start_row=3,
start_column=1,
end_row=3,
end_column=width)
cell = sheet.cell(row=3, column=1)
cell.value = gettext("From {start} to {end}:").format(
start=date_filter(self.start, "SHORT_DATE_FORMAT"),
end=date_filter(self.end, "SHORT_DATE_FORMAT"),
)
sheet.insert_rows(4)
sheet.merge_cells(start_row=4,
start_column=1,
end_row=4,
end_column=width)
def local_datetime(datetime, format_string="M. d, Y, g:i a"):
"""
Given a date, print Javascript to print local date/time if available.
"""
if not datetime:
return ""
return mark_safe("<script>document.write(localDateTime(%s, '%s'))</script><noscript>%s</noscript>" % (
time.mktime(datetime.timetuple()),
format_string,
date_filter(datetime, format_string)
))
def get_form(self, request, obj=None, **kwargs):
# Proper kwargs are form, fields, exclude, formfield_callback
if obj: # obj is not N one, so this is a change page
pass
#kwargs['exclude'] = ['foo', 'bar',]
else: # obj is None, so this is an add page
kwargs['fields'] = ('date', 'user', 'resource', 'description', 'quantity', 'unit_price', 'event')
form = super(ResourceUsageAdmin, self).get_form(request, obj, **kwargs)
form.base_fields['description'].initial = "%s: " % date_filter(datetime.date.today(), 'SHORT_DATE_FORMAT')
return form
def local_datetime(datetime, format_string="F j, Y g:m a"):
"""
Given a date, print Javascript to print local date/time if available.
"""
if not datetime:
return ""
random_id = 'date_' + str(random.random())[2:]
return mark_safe(
"<script id='%s'>insertLocalDateTime('%s', %s, '%s')</script><noscript>%s</noscript>"
% (random_id, random_id, calendar.timegm(datetime.utctimetuple()),
format_string, date_filter(datetime, format_string)))
def _add_docx_title(self, document, title):
"""Добавляет заголовок в документы docx.
Args:
document - документ с отчетом
title - название отчета
Returns: None
"""
heading = document.add_heading(title, level=1)
heading.add_run().add_break()
paragraph = document.add_paragraph(_('From '))
paragraph.add_run(date_filter(self.start,
"SHORT_DATE_FORMAT")).bold = True
paragraph.add_run(_(' to '))
paragraph.add_run(date_filter(self.end,
"SHORT_DATE_FORMAT")).bold = True
paragraph.add_run(':')
paragraph.add_run().add_break()
def test_renders_completion_dates(self):
response = self.client.get(self.url)
pixel_set = models.PixelSet.objects.get()
expected = ('<span class="completed-at">'
'Completion date: {}'
'</span>')
self.assertContains(response,
expected.format(
date_filter(pixel_set.analysis.completed_at)),
count=1,
html=True)
self.assertContains(
response,
expected.format(
date_filter(
pixel_set.analysis.experiments.get().completed_at)),
count=1,
html=True)
def track(request, start_date=None, end_date=None):
if (start_date and end_date) and (start_date != end_date):
start = datetime.strptime(start_date, '%Y-%m-%d')
end = datetime.strptime(end_date, '%Y-%m-%d')
position_list = PositionReport.objects.filter(timestamp_received__gt=start, timestamp_received__lt=end, source__display_on_maps=True).order_by('-timestamp_received')
map_info_string = 'Showing the positions received from %s to %s' % (date_filter(start), date_filter(end))
elif (start_date and not end_date) or ((start_date == end_date) and start_date):
start = datetime.strptime(start_date, '%Y-%m-%d')
end = start + timedelta(days=1)
position_list = PositionReport.objects.filter(timestamp_received__gt=start, timestamp_received__lt=end, source__display_on_maps=True).order_by('-timestamp_received')
map_info_string = 'Showing the positions received %s' % date_filter(start)
else:
position_list = PositionReport.objects.filter(source__display_on_maps=True).order_by('-timestamp_received')[:NON_DATE_REPORT_LIMIT]
map_info_string = 'Showing the last %s positions received' % NON_DATE_REPORT_LIMIT
return render_to_response('largemap.html',
{
'map_info': map_info_string,
'positions': position_list,
'google_maps_api_key': getattr(settings, 'GOOGLE_MAPS_KEY', 'not-set'),
}, context_instance=RequestContext(request))
def local_datetime(datetime, format_string="MMM DD, YYYY h:m a"):
"""
Given a date, print Javascript to print local date/time if available.
"""
if not datetime:
return ""
return mark_safe("<script>document.write(moment('%s').format('%s'))</script><noscript>%s</noscript>" % (
datetime,
format_string,
date_filter(datetime, format_string)
))
def wrapper(*args, **kwargs):
value = func(*args, **kwargs)
if not hasattr(value, 'date'):
return value
if value.date() == compare_date:
format = time_format
else:
format = datetime_format
return date_filter(value, format)
def humanize_date(value, arg='j F Y'):
if isinstance(value, datetime):
value = Pendulum.instance(value)
elif isinstance(value, date):
value = Pendulum.create(year=value.year,
month=value.month,
day=value.day)
result = naturalweekday(value)
if abs(Pendulum.now().diff(value).in_days()) > 2:
result += ' ' + date_filter(value, arg)
return result
def test_checkout_flyer_dates(self):
""" Assert multiple flyer dates get purchased for this advertisers slot.
Assert no FlyerPlacementSubdivisions get inserted into the db since this
purchase is for the entire market.
"""
kwargs = {'email':'*****@*****.**',
'consumer_zip_postal':'10990',
'business_name':'purchase flyer dates',
'short_business_name':'purchase flyer dates',
'headline':'purchase flyer dates'}
self.make_advertiser_with_slot(**kwargs)
SlotTimeFrame.objects.create(slot_id=self.slot.id,
coupon_id=self.advertiser.businesses.all(
)[0].offers.all()[0].coupons.all()[0].id)
self.login_build_set_assemble(self.advertiser)
self.session['current_slot_id'] = self.slot.id
first_purchase_date = next_flyer_date()
second_purchase_date = next_flyer_date() + datetime.timedelta(days=28)
third_purchase_date = next_flyer_date() + datetime.timedelta(days=42)
self.assertEqual(0, FlyerPlacement.objects.filter(slot__id=self.slot.id,
send_date=first_purchase_date).count())
self.assertEqual(0, FlyerPlacement.objects.filter(slot__id=self.slot.id,
send_date=second_purchase_date).count())
self.assertEqual(0, FlyerPlacement.objects.filter(slot__id=self.slot.id,
send_date=third_purchase_date).count())
flyer_subdivision_count = FlyerPlacementSubdivision.objects.count()
flyer_dates_list = [unicode(first_purchase_date),
unicode(second_purchase_date),
unicode(third_purchase_date)]
self.session['flyer_dates_list'] = flyer_dates_list
self.create_product_list(self.advertiser.site)
self.assemble_session(self.session)
response = self.client.post(reverse('checkout-coupon-purchase'),
data=self.test_credit_card_data_complete, follow=True)
# Display checkout page. Redirected (followed).
self.assertEqual(response.status_code, 200)
self.assertEqual(str(response.request['PATH_INFO']),
'/hudson-valley/create-coupon/checkout-success/')
self.common_flyer_purchase_asserts(response, first_purchase_date,
second_purchase_date)
self.assertContains(response,
'Email Flyer scheduled for %s.' %
date_filter(third_purchase_date, "M j, Y"))
self.assertEqual(1, FlyerPlacement.objects.filter(slot__id=self.slot.id,
send_date=first_purchase_date).count())
self.assertEqual(1, FlyerPlacement.objects.filter(slot__id=self.slot.id,
send_date=second_purchase_date).count())
self.assertEqual(1, FlyerPlacement.objects.filter(slot__id=self.slot.id,
send_date=third_purchase_date).count())
# Make sure no subdivision got inserted for this flyer placement since
# the flyers were being purchased for the entire market.
self.assertEqual(flyer_subdivision_count,
FlyerPlacementSubdivision.objects.count())
def test_get_add_flyer_dates(self):
""" Assert a logged in advertiser can get to the purchase flyer-by-date
page with the default checked and previous days in the month not
checked. """
self.prep_for_flyer_purchase()
response = self.client.get(reverse('add-flyer-dates',
args=[self.slot.id]))
self.assertContains(response,
self.advertiser.site.get_or_set_consumer_count())
self.assertContains(response,
'checked="checked" name="%s" value="%s"' %
(str(date_filter(next_flyer_date(), "F j")),
str(next_flyer_date())))
if int(date_filter(next_flyer_date(), "j")) > 7:
previous_date = next_flyer_date() + datetime.timedelta(days=-7)
self.assertContains(response,
'disabled="disabled" type="checkbox" ' +
'name="%s" value="%s" id="id_%s" /><span class="light">' % (
(str(date_filter(previous_date, "F j")),
str(previous_date),
str(date_filter(previous_date, "F j")))))
def table_validate_waybills(request, queryset=ets.models.Waybill.objects.all(), filtering=None):
"""Ajax view that returns list of validated/not validated waybills for using in datatables"""
if filtering in ["dispatch_validated", "validate_dispatch"]:
url = "validate_dispatch"
logger_action = ets.models.CompasLogger.DISPATCH
queryset = queryset.filter(**get_dispatch_compas_filters(request.user))
elif filtering in ["receipt_validated", "validate_receipt"]:
url = "validate_receipt"
logger_action = ets.models.CompasLogger.RECEIPT
queryset = queryset.filter(**get_receipt_compas_filters(request.user))
column_index_map = {
0: 'order__pk',
1: 'pk',
2: 'order__warehouse__name',
3: 'order__consignee__name',
4: 'order__location__name',
5: 'transport_dispach_signed_date',
6: 'receipt_signed_date',
7: 'pk',
8: 'pk',
}
params = { 'filtering': filtering } if filtering else None
redirect_url = get_api_url(request, column_index_map, "api_waybills", params)
if redirect_url:
return HttpResponse(simplejson.dumps({'redirect_url': redirect_url}), content_type="application/json; charset=utf-8")
return get_datatables_records(request, queryset, column_index_map, lambda item: [
fill_link(item.order.get_absolute_url(), item.order.pk),
fill_link(item.get_absolute_url(), item.pk),
item.order.warehouse.name,
item.order.consignee.name,
item.order.location.name,
item.transport_dispach_signed_date and date_filter(item.transport_dispach_signed_date).upper() or _("Pending"),
item.receipt_signed_date and date_filter(item.receipt_signed_date).upper() or _("Pending"),
fill_link(reverse(url, kwargs={'waybill_pk': item.pk}), _("Validate"), "validate-link"),
fill_link(reverse("waybill_errors", kwargs={'waybill_pk': item.pk, "logger_action": logger_action}), _("Show errors"), "error-link") if item.compass_loggers.filter(action=logger_action).exists() else "",
])
def datetime_string_format(value):
"""
:param value: String - Expected to be a datetime, date, or time in specific format
:return: String - reformatted to default datetime, date, or time string if received in one of the expected formats
"""
try:
new_value = date_filter(
datetime.strptime(value, CUSTOMFIELD_DATETIME_FORMAT),
settings.DATETIME_FORMAT)
except ValueError:
try:
new_value = date_filter(
datetime.strptime(value, CUSTOMFIELD_DATE_FORMAT),
settings.DATE_FORMAT)
except ValueError:
try:
new_value = date_filter(
datetime.strptime(value, CUSTOMFIELD_TIME_FORMAT),
settings.TIME_FORMAT)
except ValueError:
new_value = value
return new_value
def test_renders_release_date(self):
response = self.client.get(self.url)
expected = ('<span class="released-at">' 'Release date: {}' '</span>')
self.assertContains(
response,
expected.format(
date_filter(
self.pixel_set.analysis.experiments.get().released_at)),
count=1,
html=True)
def datetime_string_format(value):
"""
:param value: String - Expected to be a datetime, date, or time in specific format
:return: String - reformatted to default datetime, date, or time string if received in one of the expected formats
"""
try:
new_value = date_filter(
datetime.strptime(value, CUSTOMFIELD_DATETIME_FORMAT),
settings.DATETIME_FORMAT)
except (TypeError, ValueError):
try:
new_value = date_filter(
datetime.strptime(value, CUSTOMFIELD_DATE_FORMAT),
settings.DATE_FORMAT)
except (TypeError, ValueError):
try:
new_value = date_filter(
datetime.strptime(value, CUSTOMFIELD_TIME_FORMAT),
settings.TIME_FORMAT)
except (TypeError, ValueError):
# If NoneType return empty string, else return original value
new_value = "" if value is None else value
return new_value
def applications_matching_search(self, application_list): search_form = self name = search_form.cleaned_data['name'] if name: application_list = [application for application in application_list if name.lower() in application.user.get_full_name().lower()] programme = search_form.cleaned_data['programme'] if programme: application_list = [application for application in application_list if programme == application.user.profile.programme] submission_date = search_form.cleaned_data['submission_date'] if submission_date: application_list = [application for application in application_list if submission_date.lower() in date_filter( application.submission_date + timezone.timedelta(hours=2), "d M H:i").lower()] role = search_form.cleaned_data['role'] priority = (search_form.cleaned_data['priority']) # A string: 0, 1, or 2 # Three different search cases: role + priority, only role or only priority if role and priority: application_list = [application for application in application_list if (role, int(priority)) in [(roleapp.role, roleapp.order) for roleapp in application.roles]] elif role: application_list = [application for application in application_list if role in [roleapp.role for roleapp in application.roles]] elif priority: # Rare use case, matches all applications where any role has been chosen with the given priority application_list = [application for application in application_list if int(priority) in [roleapp.order for roleapp in application.roles]] interviewer = search_form.cleaned_data['interviewer'] if interviewer: application_list = [application for application in application_list if interviewer == application.interviewer] recommended_role = search_form.cleaned_data['recommended_role'] if recommended_role: application_list = [application for application in application_list if recommended_role == application.recommended_role] rating = search_form.cleaned_data['rating'] if rating: application_list = [application for application in application_list if int(rating) == application.rating] state = search_form.cleaned_data['state'] if state: application_list = [application for application in application_list if state == application.state()] return application_list
def local_datetime(datetime, format_string="F j, Y g:m a"):
"""
Given a date, print Javascript to print local date/time if available.
"""
if not datetime:
return ""
random_id = 'date_'+str(random.random())[2:]
return mark_safe("<script id='%s'>insertLocalDateTime('%s', %s, '%s')</script><noscript>%s</noscript>" % (
random_id,
random_id,
calendar.timegm(datetime.utctimetuple()),
format_string,
date_filter(datetime, format_string)
))
def table_orders(request, queryset):
"""Ajax view that returns list of orders for using in datatables"""
column_index_map = {
0: 'code',
1: 'created',
2: 'dispatch_date',
3: 'expiry',
4: 'warehouse__name',
5: 'location__name',
6: 'consignee__code',
7: 'transport_name',
8: 'code',
9: 'code',
10: 'code',
}
queryset = queryset.filter(**filter_for_orders())
redirect_url = get_api_url(request, column_index_map, "api_orders")
if redirect_url:
return HttpResponse(simplejson.dumps({'redirect_url': redirect_url}), content_type="application/json; charset=utf-8")
return get_datatables_records(request, queryset, column_index_map, lambda item: [
fill_link(item.get_absolute_url(), item.code),
date_filter(item.created).upper(),
date_filter(item.dispatch_date).upper(),
date_filter(item.expiry).upper(),
item.warehouse.name,
item.location.name,
unicode(item.consignee),
item.transport_name,
item.percentage,
fill_link(reverse('waybill_create', kwargs={'order_pk': item.pk}) \
if item.has_waybill_creation_permission(request.user) else '',
_("Create")),
item.is_expired(),
])
def calendar(context, booking_list):
start = date.today()
end = date.today() + timedelta(days=config.BOOKING_DAYS_FUTURE)
bookings_by_day = group_by(booking_list, lambda b: b.date)
output = []
for d in date_range(start, end):
if d < date.today():
output.append(format_html('<h4 class="page-header text-muted">{}</h4>', date_filter(d, 'l j \d\e F')))
elif d == date.today():
output.append(format_html('<h4 class="page-header text-warning"><b>{} (hoy)</b></h4>', date_filter(d, 'l j \d\e F')))
else:
output.append(format_html('<h4 class="page-header">{}</h4>', date_filter(d, 'l j \d\e F')))
if bookings_by_day.get(d, None):
output.append('<div class="list-group">')
for booking in bookings_by_day[d]:
if booking.status != 'x' and booking.user == context['request'].user:
actions = format_html('<a class="btn btn-xs btn-link" href="{}">Cancelar</a>', reverse('bookings:cancel', kwargs={'pk': booking.pk}))
else:
actions = ''
label_classes = {'x': 'danger', 'c': 'success', 'p': 'warning'}
output.append(format_html('<div class="list-group-item"><div class="row"><div class="col-md-4">{} {}</div> <div class="col-md-6"><span style="position: relative; top: 1px; font-weight: bold;">{}</span></div><div class="col-md-2 text-right">{}</div></div></div>',
format_html('<span class="label label-{}">{}</span>', label_classes[booking.status], booking.get_status_display()),
format_html('<span class="label label-info">Turno {}</span>', booking.get_shift_display()),
format_html('<span data-toggle="tooltip" title="{}">{}</span>', booking.user.email, booking.user.get_full_name()),
actions,
))
output.append('</div>')
else:
output.append(format_html('<p class="text-muted">{}</p>', 'No hay reservas para este día.'))
return mark_safe(''.join(output))
def get_time_series_field_verbose_name(cls, date_period, index, dates,
pattern):
"""
Get the name of the verbose name of a computaion field that's in a time_series.
should be a mix of the date period if the column an it's verbose name.
:param date_period: a tuple of (start_date, end_date)
:param index: the index of the current field in the whole dates to be calculated
:param dates a list of tuples representing the start and the end date
:return: a verbose string
"""
dt_format = '%Y/%m/%d'
if pattern == 'monthly':
month_name = date_filter(date_period[0], 'F Y')
return f'{cls.verbose_name} {month_name}'
elif pattern == 'daily':
return f'{cls.verbose_name} {date_period[0].strftime(dt_format)}'
elif pattern == 'weekly':
return f' {cls.verbose_name} {_("Week")} {index} {date_period[0].strftime(dt_format)}'
elif pattern == 'yearly':
year = date_filter(date_period[0], 'Y')
return f'{cls.verbose_name} {year}'
return f'{cls.verbose_name} {date_period[0].strftime(dt_format)} - {date_period[1].strftime(dt_format)}'
def format_datetime(dt, format=None):
"""
Takes an instance of datetime, converts it to the current timezone and
formats it as a string. Use this instead of
django.core.templatefilters.date, which expects localtime.
:param format: Common will be settings.DATETIME_FORMAT or
settings.DATE_FORMAT, or the resp. shorthands
('DATETIME_FORMAT', 'DATE_FORMAT')
"""
if is_naive(dt):
localtime = make_aware(dt, get_current_timezone())
logging.warning(
"helpers.utils.format_datetime received native datetime")
else:
localtime = dt.astimezone(get_current_timezone())
return date_filter(localtime, format)
def make_pdf(self):
reg = self.registration
event = reg.event
address = f"""
_{reg.letter.name}_\u0020\u0020
_{reg.letter.address}_
"""
intro = f"""
On behalf of the {event.name} organizing committee, I would hereby like to invite
_Name: **{reg.letter.name}**_\u0020\u0020
_Passport number: **{reg.letter.passport_number}**_\u0020\u0020
_Nationality: **{reg.letter.nationality}**_\u0020\u0020
to attend the \u201C{event.full_name} ({event.name})\u201D
from {date_filter(event.start_date)} to {date_filter(event.end_date)}
in {event.city}, {event.country.name}.
"""
signature = f"""
More information about this event can be found on:\u0020\u0020
<{event.website}>
We look forward to welcoming {reg.letter.name} in {event.city}.\u0020\u0020
Please do not hesitate to contact me for additional information.\u0020\u0020
Sincerely yours,
"""
with Pdf() as pdf:
pdf.add_text(date_filter(timezone.now()), "p_right")
pdf.add_text(address, "p_small", "markdown")
pdf.add_spacer(1.5)
pdf.add_text("To Whom It May Concern,")
pdf.add_text(intro, "p", "markdown")
if reg.letter.submitted:
paper = f"""
{reg.user.profile.name} has submitted a {reg.letter.submitted} titled \u2018{reg.letter.submitted_title}\u2019
with the intention to present it during the event.
"""
pdf.add_text(paper, "p", "markdown")
pdf.add_text(signature, "p", "markdown")
pdf.add_spacer(1.5)
pdf.add_text(event.signature, "p", "markdown")
pdf.add_page_break()
self._response.write(pdf.get())
def format_datetime(dt, format=None):
"""
Takes an instance of datetime, converts it to the current timezone and
formats it as a string. Use this instead of
django.core.templatefilters.date, which expects localtime.
:param format: Common will be settings.DATETIME_FORMAT or
settings.DATE_FORMAT, or the resp. shorthands
('DATETIME_FORMAT', 'DATE_FORMAT')
"""
if is_naive(dt):
localtime = make_aware(dt, get_current_timezone())
logging.warning(
"oscar.core.utils.format_datetime received native datetime")
else:
localtime = dt.astimezone(get_current_timezone())
return date_filter(localtime, format)
def get_context_data(self, **kwargs):
context = super(ContestCalendar, self).get_context_data(**kwargs)
try:
month = date(self.year, self.month, 1)
except ValueError:
raise Http404()
else:
context['title'] = _('Contests in %(month)s') % {
'month': date_filter(month, _("F Y"))
}
dates = Contest.objects.aggregate(min=Min('start_time'),
max=Max('end_time'))
min_month = (self.today.year, self.today.month)
if dates['min'] is not None:
min_month = dates['min'].year, dates['min'].month
max_month = (self.today.year, self.today.month)
if dates['max'] is not None:
max_month = max((dates['max'].year, dates['max'].month),
(self.today.year, self.today.month))
month = (self.year, self.month)
if month < min_month or month > max_month:
# 404 is valid because it merely declares the lack of existence, without any reason
raise Http404()
context['now'] = timezone.now()
context['calendar'] = self.get_table()
context['curr_month'] = date(self.year, self.month, 1)
if month > min_month:
context['prev_month'] = date(
self.year - (self.month == 1),
12 if self.month == 1 else self.month - 1, 1)
else:
context['prev_month'] = None
if month < max_month:
context['next_month'] = date(
self.year + (self.month == 12),
1 if self.month == 12 else self.month + 1, 1)
else:
context['next_month'] = None
return context
def send_favorites(hours=25, queue=None, limit_to_username=None):
from event.models import RecommendedEvent, Event
from event.templatetags.eventtags import event_friends
from registration.models import UserProfile
now = date.today()
add_date_threshold = date.today() - timedelta(hours=hours)
profiles = UserProfile.objects.active().filter(
send_favorites=True).order_by('pk')
if limit_to_username:
profiles = profiles.filter(user__username=limit_to_username)
n = 0
q = queue or EventsQ(bind_queue=False)
for p in profiles:
a = p.user
d = dict(email_type='favorites',
attendee__username=a.username,
attendee__email=a.email,
attendee__first_name=a.first_name,
attendee__last_name=a.last_name,
attendee_profile_id=p.pk)
picks = Event.objects.active().select_related('artist').filter(
recommendedevent__user_profile=p,
recommendedevent__added_on__gte=add_date_threshold,
).distinct().order_by('event_date', 'event_start_time')
if picks:
ripe_picks = []
d['ripe_picks'] = ripe_picks
for rp in picks:
ripe = dict(
event__event_url=rp.get_absolute_url(force_hostname=True),
event__title=rp.title,
event__event_date=date_filter(rp.event_date, "l, N j, Y"),
event__event_start_time=time_filter(rp.event_start_time),
event__event_timezone=rp.event_timezone,
)
ripe_picks.append(ripe)
num_fr = event_friends(rp, p).lower().replace('| ', '')
if num_fr.endswith("friend"):
num_fr = "<b>" + num_fr + "</b> is interested in"
elif num_fr.endswith("friends"):
num_fr = "<b>" + num_fr + "</b> are interested in"
ripe['num_friends'] = num_fr
send_event_reminder(d, queue=q, email_type='favorites')
n += 1
_log.debug("%s event favorite emails sent", n)
def digest_for_date(date: dt.date) -> None:
articles = Article.objects.published().for_date(date).order_by("-date")
if articles.count() == 0:
return
scheme = settings.SITE_SCHEME
site = Site.objects.get_current()
title = "Digest for {}".format(date_filter(date, "jS F Y"))
sender = settings.DEFAULT_FROM_EMAIL
for subscription in Subscription.objects.confirmed():
cancel_url = "{}://{}{}?action=cancel&token={}".format(
scheme, site.domain, reverse("subscribe"), subscription.token)
context = {
"title": title,
"date": date,
"site_name": site.name,
"objects": articles,
"receiver": subscription.email,
"cancel_url": cancel_url,
}
template = "lynx/emails/digest_body.html"
formatted = get_template(template).render(context)
inlined = inline_css(formatted)
template = "lynx/emails/digest_body.txt"
plain = get_template(template).render(context)
Email.objects.create(
sender=sender,
receivers=subscription.email,
subject=title,
formatted=inlined,
plain=plain,
sent_at=None,
)
