def test_suggestion_tag_reverse(self):
# Create a suggestion and tags but with a missing reverse reference.
Reminder(key_name='a-b', title='a b', tags='a b'.split()).put()
Reminder(key_name='b-c', title='b c', tags='b'.split()).put()
Tag(key_name='a', suggestions='a-b'.split(), count=0).put()
Tag(key_name='b', suggestions='b-c'.split(), count=0).put()
self.assertEqual(Reminder.all().count(), 2)
self.assertEqual(Tag.all().count(), 2)
self.assertEqual(len(Tag.get_by_key_name('b').suggestions), 1)
# Check that the missing tag-reminder reference is detected.
response = self.client.get('/consistency/')
self.assertTrue('suggestion_tag_reverse'
in response.context['problems'])
self.assertTrue("Suggestion a-b references b but not reverse."
in response.content)
# Simulate button click to fix this problem.
response = self.client.post('/consistency/', {
'suggestion_tag_reverse': "Create reverse references"})
self.assertRedirects(response, '/consistency/')
# Check that the tags are now existing.
self.assertEqual(Reminder.all().count(), 2)
self.assertEqual(Tag.all().count(), 2)
self.assertEqual(len(Tag.get_by_key_name('b').suggestions), 2)
response = self.client.get('/consistency/')
self.assertFalse('suggestion_tag_reverse'
in response.context['problems'])
def submit_suggestion(request, suggestion_form):
"""
Save a new suggestion in the database.
"""
slug = suggestion_form.cleaned_data['slug']
tag_list = suggestion_form.cleaned_data['tags'].split()
for tag_name in tag_list:
tag = Tag.get_by_key_name(tag_name)
if tag is None:
tag = Tag(key_name=tag_name, count=0)
tag.suggestions.append(slug)
tag.count += 1
tag.put()
suggestion = Reminder(
key_name=slug,
title=suggestion_form.cleaned_data['title'],
days=suggestion_form.cleaned_data['days'],
months=suggestion_form.cleaned_data['months'],
years=suggestion_form.cleaned_data['years'],
miles=suggestion_form.cleaned_data['miles'],
kilometers=suggestion_form.cleaned_data['kilometers'],
tags=tag_list)
logging.debug(suggestion)
suggestion.put()
return HttpResponseRedirect(suggestion.get_absolute_url())
def test_reminder(self):
reminder = Reminder(
title="Replace smoke alarm batteries", year=1,
tags='home safety fire smoke alarm batteries'.split(),
next=datetime(2008, 10, 10, 10, 10, 10),
owner=self.user)
reminder.put()
self.assertEqual(unicode(reminder), "Replace smoke alarm batteries")
def save(self, commit=True):
account = super(RegisterForm, self).save()
account.user.set_password(self.cleaned_data['password'])
account.user.is_active = True
account.user.save()
Reminder.create_defaults(account)
return super(RegisterForm, self).save(commit=commit)
def test_suggestion(self):
suggestion = Reminder(
title="Replace smoke alarm batteries",
tags='home safety smoke fire alarm batteries'.split(),
days=7)
suggestion.put()
self.assertEqual(unicode(suggestion), "Replace smoke alarm batteries")
self.assertTrue('home' in suggestion.tags)
self.assertTrue('safety' in suggestion.tags)
self.assertEqual(len(suggestion.tags), 6)
self.assertEqual(suggestion.interval(), 'week')
def create_reminder(request, user, suggestion):
reminder = Reminder(
owner=user,
title=suggestion.title,
tags=suggestion.tags,
days=suggestion.days,
months=suggestion.months,
years=suggestion.years,
miles=suggestion.miles,
kilometers=suggestion.kilometers)
reminder.put()
Message(message='<p class="success message">%s</p>' %
"Your reminder was created successfully. You can edit it below.",
user=user).put()
return HttpResponseRedirect(reminder.get_absolute_url())
def save_reminder(request):
name = request.GET.get('reminder_name')
phone_number = request.GET.get('reminder_phone_number')
date = request.GET.get('reminder_date')
time = request.GET.get('reminder_time')
url = request.GET.get('reminder_url')
date_combined = date + ' ' + time
print(name, phone_number, date_combined, url)
reminder = Reminder(name=name,
phone_number=phone_number,
time=date_combined,
link=url)
reminder.save()
print(reminder.phone_number)
return redirect('/main')
def dump_app(request, app_name, format):
if app_name == 'reminders':
reminder_list = Reminder.all()
elif app_name == 'tags':
tag_list = Tag.all()
template = 'dumpdata/%s.%s' % (app_name, format)
return render_to_response(request, template, locals())
def test_permissions(self):
"""
Make sure the basic permission things are as-expected.
"""
c = Client()
# a role reminder: users with the role, but not others
r = Reminder(
reminder_type='ROLE',
role='ADVS',
unit=Unit.objects.get(slug='cmpt'),
date_type='SEM',
week=4,
weekday=0,
person=Person.objects.get(userid='ggbaker'),
title='Advisor reminder',
content='foo',
)
r.save()
url = reverse('reminders:view', kwargs={'reminder_slug': r.slug})
c.login_user('ggbaker')
resp = c.get(url)
self.assertEqual(resp.status_code, 404)
c.login_user('dzhao')
resp = c.get(url)
self.assertEqual(resp.status_code, 200)
# a personal reminder: that person only
r = Reminder(reminder_type='PERS',
date_type='YEAR',
month='5',
day=31,
person=Person.objects.get(userid='ggbaker'),
title='Personal reminder',
content='### Heading\n\nfoo *bar*',
config={'markup': 'markdown'})
r.save()
url = reverse('reminders:view', kwargs={'reminder_slug': r.slug})
c.login_user('ggbaker')
resp = c.get(url)
self.assertEqual(resp.status_code, 200)
c.login_user('dzhao')
resp = c.get(url)
self.assertEqual(resp.status_code, 404)
# test the HTML generation while we're here
self.assertEqual(r.html_content().replace('\n', ''),
'<h3>Heading</h3><p>foo <em>bar</em></p>')
def test_tag_created_later(self):
# Create a tag with timestamp later than suggestion.
Reminder(key_name='a-b', title='a b', tags='a b'.split()).put()
later = Reminder.get_by_key_name('a-b').created + timedelta(seconds=1)
Tag(key_name='a', suggestions=['a-b'], count=1, created=later).put()
# Check that the missing timestamp is detected.
response = self.client.get('/consistency/')
self.assertTrue('tag_created_later' in response.context['problems'])
self.assertTrue("Tag a was created after suggestion a-b."
in response.content)
# Simulate button click to fix this problem.
response = self.client.post('/consistency/',
{'tag_created_later': "Adjust timestamps"})
self.assertRedirects(response, '/consistency/')
# Check that the timestamps are now correct.
self.assertEqual(Reminder.get_by_key_name('a-b').created,
Tag.get_by_key_name('a').created)
response = self.client.get('/consistency/')
self.assertFalse('tag_created_later' in response.context['problems'])
def create_raw_account(cls, request):
"""
Creates raw user object and get or create account object on sign up
"""
email = request.POST.get('email', None)
if not email or User.objects.filter(username__iexact=email).exists():
return None
password = "".join([choice("abcdefghijklmnopqrstuvwxyz1234567890") for i in xrange(10)])
token = request.session.session_key
if not token:
request.session.modified = True
user = User(username=email.lower(), email=email.lower(), is_active=False)
user.set_password(password)
user.save()
account, created = Account.objects.get_or_create(token=token)
account.user = user
account.save()
Reminder.create_defaults(account)
from prays.models import PrayerBook
PrayerBook.create_defaults(account)
return account
def get_account(cls, request):
if not request.session.exists(request.session.session_key):
request.session.create()
if request.user.is_authenticated():
try:
return Account.objects.get(user=request.user)
except Account.DoesNotExist:
account, created = Account.objects.get_or_create(token=request.session.session_key)
account.user = request.user
account.anonym = False
account.save()
Reminder.create_defaults(account)
from prays.models import PrayerBook
PrayerBook.create_defaults(account)
return account
except Exception:
return None
else:
account, created = Account.objects.get_or_create(anonym=True, token=request.session.session_key)
Reminder.create_defaults(account)
return account
def index(request):
"""
Display the current system status.
"""
# Simple form to add new suggestions.
suggestion_form = SuggestionForm(request.POST or None)
if suggestion_form.is_valid():
return submit_suggestion(request, suggestion_form)
# Recent time intervals.
day = datetime.now() - timedelta(hours=24)
week = datetime.now() - timedelta(days=7)
# Show newest suggestions.
suggestion_count = Reminder.all().filter('owner', None).count()
suggestion_count_24h = (Reminder.all().filter('owner', None)
.filter('created >', day).count())
suggestion_count_7d = (Reminder.all().filter('owner', None)
.filter('created >', week).count())
suggestion_list = (Reminder.all().filter('owner', None)
.order('-created').fetch(RECENT_LIMIT))
# Show newest tags.
tag_count = Tag.all().count()
tag_count_24h = Tag.all().filter('created >', day).count()
tag_count_7d = Tag.all().filter('created >', week).count()
tag_list = Tag.all().order('-created').fetch(RECENT_LIMIT * 4)
# Registered user accounts.
user_count = User.all().count()
user_count_24h = User.all().filter('date_joined >', day).count()
user_count_7d = User.all().filter('date_joined >', week).count()
user_list = User.all().order('-date_joined').fetch(RECENT_LIMIT)
# Show newest feedback.
# feedback_count = Feedback.all().count()
# feedback_count_24h = Feedback.all().filter('submitted >', day).count()
# feedback_count_7d = Feedback.all().filter('submitted >', week).count()
# feedback_list = Feedback.all().order('-submitted').fetch(RECENT_LIMIT)
return render_to_response(request, 'dashboard/index.html', locals())
def create(validated_data):
reminder = Reminder()
reminder.customer = validated_data['customer']
reminder.message = validated_data.get('message')
reminder.scheduled_datetime = validated_data.get('scheduled_datetime')
reminder.save()
if validated_data.get('phone_number'):
customer = validated_data['customer']
customer.phone = validated_data.get('phone_number', customer.phone)
customer.save()
return reminder
def cloudStorage(request):
if request.method == "POST":
company_name = request.POST['company_name']
expire_date =request.POST['expire_date']
if Reminder.objects.filter(user=request.user, company_name=company_name).exists():
storage = messages.get_messages(request)
storage.used = True
messages.error(request, 'You have already set a reminder for this.You can view it in your dashboard')
return redirect('cloudStorage')
reminder = Reminder(company_name=company_name, expire_date=expire_date, user=request.user)
reminder.save()
storage = messages.get_messages(request)
storage.used = True
messages.success(request, 'Reminder was added successfully')
return redirect('cloudStorage')
return render(request, 'pages/cloudStorage.html')
def handle_delete_reminder(bot, update):
user = User.get(update.user_id)
reminder = Reminder.get(update.cmd_args['reminder_id'])
if reminder:
execute_database_command(
f'DELETE FROM reminders WHERE id = {reminder.id};')
bot.delete_message(update.message.body.mid)
else:
ru_text = f'Такого напоминания не существует'
en_text = f'This reminder does not exists'
text = ru_text if user.language_code == 'ru' else en_text
bot.send_message(update.user_id, text)
def send_period_reminders(event_ids, sendsms=False, turn_off_reminders=False, mailgun_campaign_id=None):
"""
takes a Period object
uses the Period to get appointments and then send reminders
"""
appointments = Appointment.objects.filter(event__id__in=event_ids).exclude(no_reminders=True).distinct()
if appointments:
for appointment in appointments:
sent_email = False
sent_sms = False
if appointment.client.phone and sendsms and getattr(settings, 'SENDSMS', False):
if appointment.customer.send_sms:
if appointment.venue.send_sms:
send_sms_reminder(appointment)
sent_sms = True
if appointment.client.email:
if appointment.customer.send_email:
if appointment.venue.send_email:
send_email_reminder(appointment, mailgun_campaign_id)
sent_email = True
if True in [sent_email, sent_sms]:
if turn_off_reminders:
appointment.no_reminders = True
appointment.save()
if appointment.status != Appointment.CONFIRMED and appointment.status != Appointment.CANCELED:
appointment.status = Appointment.NOTIFIED
appointment.save()
reminder = Reminder(
customer=appointment.customer,
appointment=appointment,
client_name=appointment.client.get_full_name(),
appointment_time=timezone.localtime(appointment.event.start),
sent_email=sent_email,
sent_sms=sent_sms
)
reminder.save()
def test_tag_suggestion_reverse(self):
# Create a suggestion and a tag.
Reminder(key_name='a-b', title='a b', tags='b'.split()).put()
Tag(key_name='a', count=2, suggestions='a-b a-c'.split()).put()
# Check that the missing reverse reference is detected.
response = self.client.get('/consistency/')
self.assertTrue('tag_suggestion_reverse'
in response.context['problems'])
self.assertTrue("Tag a references a-b but not reverse."
in response.content)
# Simulate button click to fix this problem.
response = self.client.post('/consistency/', {
'tag_suggestion_reverse': "Create reverse references"})
self.assertRedirects(response, '/consistency/')
# Check that the missing references were created.
self.assertTrue('a' in Reminder.get_by_key_name('a-b').tags)
response = self.client.get('/consistency/')
self.assertFalse('tag_suggestion_reverse'
in response.context['problems'])
def set_user_updates(user, chat_id, hour, lang):
logger.info(_("User updating", chat_id=chat_id))
reminder = Reminder.objects.filter(chat_id=chat_id).first()
if reminder is None:
reminder = Reminder(chat_id=chat_id)
if lang is not None:
reminder.lang = lang
reminder.hour = hour
reminder.save()
return
def test_permissions(self):
"""
Make sure the basic permission things are as-expected.
"""
c = Client()
# a role reminder: users with the role, but not others
r = Reminder(reminder_type='ROLE', role='ADVS', unit=Unit.objects.get(slug='cmpt'),
date_type='SEM', week=4, weekday=0,
person=Person.objects.get(userid='ggbaker'), title='Advisor reminder', content='foo',)
r.save()
url = reverse('reminders:view', kwargs={'reminder_slug': r.slug})
c.login_user('ggbaker')
resp = c.get(url)
self.assertEqual(resp.status_code, 404)
c.login_user('dzhao')
resp = c.get(url)
self.assertEqual(resp.status_code, 200)
# a personal reminder: that person only
r = Reminder(reminder_type='PERS',
date_type='YEAR', month='5', day=31,
person=Person.objects.get(userid='ggbaker'), title='Personal reminder',
content='### Heading\n\nfoo *bar*', config={'markup': 'markdown'})
r.save()
url = reverse('reminders:view', kwargs={'reminder_slug': r.slug})
c.login_user('ggbaker')
resp = c.get(url)
self.assertEqual(resp.status_code, 200)
c.login_user('dzhao')
resp = c.get(url)
self.assertEqual(resp.status_code, 404)
# test the HTML generation while we're here
self.assertEqual(r.html_content().replace('\n', ''), '<h3>Heading</h3><p>foo <em>bar</em></p>')
def test_message_generation(self):
"""
Make sure ReminderMessage objects are generated as expected.
"""
kwargs = {'reminder_type': 'PERS', 'person': Person.objects.get(userid='ggbaker'),
'title': 'Test reminder', 'content': 'foo'}
m, d = self._month_day_offset(3) # near future: remindermessage should generate
r0 = Reminder(date_type='YEAR', month=m, day=d, **kwargs)
r0.save()
m, d = self._month_day_offset(-30) # distant past: remindermessage should not generate
r1 = Reminder(date_type='YEAR', month=m, day=d, **kwargs)
r1.save()
m, d = self._month_day_offset(90) # far future: remindermessage should not generate
r2 = Reminder(date_type='YEAR', month=m, day=d, **kwargs)
r2.save()
Reminder.create_all_reminder_messages()
rms = list(ReminderMessage.objects.all())
self.assertTrue(len(rms) >= 1) # may be other reminders from fixture objects, depending on run date
rm = rms[0]
self.assertEqual(rm.reminder, r0)
self.assertEqual(rm.sent, False)
ReminderMessage.send_all()
self.assertEqual(rm.sent, False) # shouldn't send: still in the future
from django.conf.urls.defaults import *
from django.views.generic.list_detail import object_list, object_detail
from reminders.models import Reminder
info_dict = {
'queryset': Reminder.all().filter('owner', None),
'template_object_name': 'suggestion',
}
urlpatterns = patterns('suggestions.views',
url(r'^$', object_list,
dict(info_dict, template_name='suggestions/index.html'),
name='suggestion_list'),
url(r'^(?P<key_name>[a-z0-9-]+)/$', 'detail'),
)
def create_reminders():
from reminders.models import Reminder
person = find_person('ggbaker')
offering = CourseOffering.objects.get(slug=TEST_COURSE_SLUG)
r1 = Reminder(title='New Year', reminder_type='PERS', person=person, content="Happy new year! It's Jan 1.",
date_type='YEAR', month=1, day=1)
r1.save()
r2 = Reminder(title='Start of semester', reminder_type='ROLE', role='SYSA', unit=Unit.objects.get(slug='univ'),
content="The new semester started a while ago, in case you weren't paying attention.",
date_type='SEM', week=2, weekday=1, person=person)
r2.save()
r3 = Reminder(title='Create an exam', reminder_type='INST', course=offering.course,
content="It's probably *almost* time for the final exam.\r\n\r\nCreate it.",
date_type='SEM', week=12, weekday=4, person=person)
r3.markup = 'markdown'
r3.save()
r4 = Reminder(title='Deleted reminder', reminder_type='PERS', person=person, content="This has been deleted and shouldn't be visible.",
date_type='SEM', week=5, weekday=2, status='D')
r4.save()
return Reminder.all_objects.all()
def index(request):
"""
List all reminders for a registered user.
"""
reminder_list = Reminder.all().filter('owner', request.user)
return render_to_response(request, 'reminders/index.html', locals())
def index(request):
"""
Check reminders and tags for consistency.
"""
if (request.META.get('HTTP_X_APPENGINE_CRON', '') != 'true'
and not request.user.is_staff):
return HttpResponseRedirect('/accounts/login/?next=/consistency/')
# Get all tags and suggestions from the datastore.
tag_dict = dict((tag.key().name(), tag) for tag in Tag.all())
suggestion_dict = dict((suggestion.key().name(), suggestion)
for suggestion in Reminder.all().filter('owner', None))
# Initialize empty problems dict.
problems = dict((problem, []) for problem in PROBLEM_MESSAGES)
# Check all tags.
for tag_key, tag in tag_dict.items():
if tag.count != len(tag.suggestions):
problems['tag_count'].append(
(tag, tag.count, len(tag.suggestions)))
elif tag.count == 0:
problems['tag_empty'].append((tag, ))
oldest = None
for suggestion_key in tag.suggestions:
if tag.suggestions.count(suggestion_key) > 1:
problems['tag_suggestion_duplicate'].append(
(tag, tag.suggestions.count(suggestion_key),
suggestion_key))
if suggestion_key not in suggestion_dict:
problems['tag_suggestion_missing'].append(
(tag, suggestion_key))
continue
suggestion = suggestion_dict[suggestion_key]
if tag.key().name() not in suggestion.tags:
problems['tag_suggestion_reverse'].append((tag, suggestion))
if oldest is None or suggestion.created < oldest.created:
oldest = suggestion
if oldest:
if tag.created is None:
problems['tag_created_none'].append((tag, oldest))
elif tag.created > oldest.created:
problems['tag_created_later'].append((tag, oldest))
# Check all suggestions.
for suggestion_key, suggestion in suggestion_dict.items():
for tag_key in suggestion.tags:
if tag_key not in tag_dict:
problems['suggestion_tag_missing'].append(
(suggestion, tag_key))
continue
tag = tag_dict[tag_key]
if suggestion.key().name() not in tag.suggestions:
problems['suggestion_tag_reverse'].append((suggestion, tag))
# Check all feedback submitters.
for feedback in Feedback.all().filter('submitter !=', None):
try:
submitter = feedback.submitter # Attempt to dereference.
except datastore_errors.Error:
problems['feedback_submitter'].append((feedback, request.user))
# Check all reminders.
for reminder in Reminder.all().filter('owner !=', None):
try:
owner = reminder.owner # Attempt to dereference.
except datastore_errors.Error:
problems['reminder_owner'].append((reminder, request.user))
# Remove empty problem sections.
for problem in PROBLEM_MESSAGES:
if not problems[problem]:
assert problems.pop(problem) == []
# Return plain-text summary if cron is calling, development test with:
# curl --header "X-AppEngine-Cron: true" http://localhost:8000/consistency/
if request.META.get('HTTP_X_APPENGINE_CRON', '') == 'true':
message = []
for problem in problems:
message.append(PROBLEM_HEADLINES[problem].rstrip('.') + ':')
for data in problems[problem]:
message.append("* " + format_problem(problem, data))
message.append('')
if not message:
message.append("No problems found.")
message.append('')
message.append('http://www.minderbot.com/consistency/')
message.append('')
message = '\n'.join(message)
if problems:
if request.META.get('HTTP_USER_AGENT', '') != 'django.test.Client':
logging.error(message)
mail_admins('Consistency check found problems',
message, fail_silently=True)
return HttpResponse(message, mimetype="text/plain")
# Fix inconsistencies if admin clicked one of the buttons.
if request.user.is_staff:
for problem in problems:
if problems[problem] and problem in request.POST:
func = getattr(repair, problem)
assert callable(func)
for item in problems[problem]:
func(*item)
return HttpResponseRedirect(request.path)
# Collect errors and remove sections without problems.
consistency_results = []
for problem in problems:
consistency_results.append(
(problem,
PROBLEM_HEADLINES[problem],
[format_problem(problem, item) for item in problems[problem]],
PROBLEM_BUTTONS[problem]))
consistency_results.sort()
return render_to_response(request, 'consistency/index.html', locals())
def _create_cancellation_reminders(customer, order, answers):
answer = answers[-1].strip().upper()
reason = LIST_40305014_CHOICES.get(answer)
reason = LIST_49961703_CHOICES.get(answer, reason)
reason = LIST_40409961_CHOICES.get(answer, reason)
name = customer.first_name
email = customer.user.email
order_count = customer.get_count_orders()
personal_voucher = Reminder.generate_voucher(name, email)
ctz = timezone.get_current_timezone()
now = ctz.normalize(timezone.now())
if reason == "much":
if order_count < 3:
Reminder.objects.create(
username=name,
email=email,
from_email='Faye from Hook Coffee <*****@*****.**>',
subject='Have you run out yet {}?'.format(name),
template_name='React_Trial_TooMuchCoffeeEmail1',
scheduled=now + timedelta(days=5),
)
Reminder.objects.create(
username=name,
email=email,
from_email='Faye from Hook Coffee <*****@*****.**>',
subject='Tailor your coffee order with Hook...',
template_name='React_Trial_TooMuchCoffeeEmail2',
scheduled=now + timedelta(days=10),
)
Reminder.objects.create(
username=name,
email=email,
from_email='Faye from Hook Coffee <*****@*****.**>',
subject='15 cups of coffee for just $14',
template_name='React_Trial_TooMuchCoffeeEmail3',
scheduled=now + timedelta(days=15),
)
else:
Reminder.objects.create(
username=name,
email=email,
from_email='Faye from Hook Coffee <*****@*****.**>',
subject='Have you run out yet {}?'.format(name),
template_name='React_Active_TooMuchCoffeeEmail1',
scheduled=now + timedelta(days=5),
)
Reminder.objects.create(
username=name,
email=email,
from_email='Faye from Hook Coffee <*****@*****.**>',
subject='Tailor your coffee order with Hook...',
template_name='React_Active_TooMuchCoffeeEmail2',
scheduled=now + timedelta(days=10),
)
Reminder.objects.create(
username=name,
email=email,
from_email='Faye from Hook Coffee <*****@*****.**>',
subject='15 cups of coffee for just $14',
template_name='React_Active_TooMuchCoffeeEmail3',
scheduled=now + timedelta(days=15),
)
elif reason == "light":
recommended_coffee = order.customer.get_recommended_coffee_for_cancellations(
order, reason)
if order_count < 3:
Reminder.objects.create(
username=name,
email=email,
from_email='Faye from Hook Coffee <*****@*****.**>',
subject='{}, fancy $2 off each of your next three orders?'.
format(name),
template_name='React_Trial_CoffeeTooLight_Email1',
scheduled=now + timedelta(days=7),
recommended_coffee=recommended_coffee,
)
Reminder.objects.create(
username=name,
email=email,
from_email='Faye from Hook Coffee <*****@*****.**>',
subject='Just 24 hours remaining to claim a $6 discount',
template_name='React_Trial_CoffeeTooLight_Email2',
scheduled=now + timedelta(days=14),
recommended_coffee=recommended_coffee,
)
else:
Reminder.objects.create(
username=name,
email=email,
from_email='Faye from Hook Coffee <*****@*****.**>',
subject='{}, fancy $4 off each of your next three orders?'.
format(name),
template_name='React_Active_CoffeeTooLight_Email1',
scheduled=now + timedelta(days=7),
recommended_coffee=recommended_coffee,
)
Reminder.objects.create(
username=name,
email=email,
from_email='Faye from Hook Coffee <*****@*****.**>',
subject='Just 24 hours remaining to claim a $12 discount',
template_name='React_Active_CoffeeTooLight_Email2',
scheduled=now + timedelta(days=14),
recommended_coffee=recommended_coffee,
)
elif reason == "dark":
recommended_coffee = order.customer.get_recommended_coffee_for_cancellations(
order, reason)
if order_count < 3:
Reminder.objects.create(
username=name,
email=email,
from_email='Faye from Hook Coffee <*****@*****.**>',
subject='{}, fancy $2 off each of your next three orders?'.
format(name),
template_name='React_Trial_CoffeeTooDark_Email1',
scheduled=now + timedelta(days=7),
recommended_coffee=recommended_coffee,
)
Reminder.objects.create(
username=name,
email=email,
from_email='Faye from Hook Coffee <*****@*****.**>',
subject='Just 24 hours remaining to claim a $6 discount',
template_name='React_Trial_CoffeeTooDark_Email2',
scheduled=now + timedelta(days=14),
recommended_coffee=recommended_coffee,
)
else:
Reminder.objects.create(
username=name,
email=email,
from_email='Faye from Hook Coffee <*****@*****.**>',
subject='{}, fancy $2 off each of your next three orders?'.
format(name),
template_name='React_Active_CoffeeTooDark_Email1',
scheduled=now + timedelta(days=7),
recommended_coffee=recommended_coffee,
)
Reminder.objects.create(
username=name,
email=email,
from_email='Faye from Hook Coffee <*****@*****.**>',
subject='Just 24 hours remaining to claim a $6 discount',
template_name='React_Active_CoffeeTooDark_Email2',
scheduled=now + timedelta(days=14),
recommended_coffee=recommended_coffee,
)
elif reason == "sour":
recommended_coffee = order.customer.get_recommended_coffee_for_cancellations(
order, reason)
if order_count < 3:
Reminder.objects.create(
username=name,
email=email,
from_email='Faye from Hook Coffee <*****@*****.**>',
subject='{}, fancy $2 off each of your next three orders?'.
format(name),
template_name='React_Trial_CoffeeTooSour_Email1',
scheduled=now + timedelta(days=7),
recommended_coffee=recommended_coffee,
)
Reminder.objects.create(
username=name,
email=email,
from_email='Faye from Hook Coffee <*****@*****.**>',
subject='Just 24 hours remaining to claim a $6 discount',
template_name='React_Trial_CoffeeTooSour_Email2',
scheduled=now + timedelta(days=14),
recommended_coffee=recommended_coffee,
)
else:
Reminder.objects.create(
username=name,
email=email,
from_email='Faye from Hook Coffee <*****@*****.**>',
subject='{}, fancy $2 off each of your next three orders?'.
format(name),
template_name='React_Active_CoffeeTooSour_Email1',
scheduled=now + timedelta(days=7),
recommended_coffee=recommended_coffee,
)
Reminder.objects.create(
username=name,
email=email,
from_email='Faye from Hook Coffee <*****@*****.**>',
subject='Just 24 hours remaining to claim a $6 discount',
template_name='React_Active_CoffeeTooSour_Email2',
scheduled=now + timedelta(days=14),
recommended_coffee=recommended_coffee,
)
# elif reason == "caffeine":
# if order_count < 3:
# Reminder.objects.create(
# username=name,
# email=email,
# from_email='Faye from Hook Coffee <*****@*****.**>',
# subject='',
# template_name='',
# scheduled=now + timedelta(days=1),
# )
# Reminder.objects.create(
# username=name,
# email=email,
# from_email='Faye from Hook Coffee <*****@*****.**>',
# subject='',
# template_name='',
# scheduled=now + timedelta(days=5),
# )
# Reminder.objects.create(
# username=name,
# email=email,
# from_email='Faye from Hook Coffee <*****@*****.**>',
# subject='',
# template_name='',
# scheduled=now + timedelta(days=7),
# )
# Reminder.objects.create(
# username=name,
# email=email,
# from_email='Faye from Hook Coffee <*****@*****.**>',
# subject='',
# template_name='',
# scheduled=now + timedelta(days=14),
# )
# else:
# Reminder.objects.create(
# username=name,
# email=email,
# from_email='Faye from Hook Coffee <*****@*****.**>',
# subject='',
# template_name='',
# scheduled=now + timedelta(days=1),
# # voucher=personal_voucher
# )
# Reminder.objects.create(
# username=name,
# email=email,
# from_email='Faye from Hook Coffee <*****@*****.**>',
# subject='',
# template_name='',
# scheduled=now + timedelta(days=5),
# # voucher=personal_voucher
# )
# Reminder.objects.create(
# username=name,
# email=email,
# from_email='Faye from Hook Coffee <*****@*****.**>',
# subject='',
# template_name='',
# scheduled=now + timedelta(days=7),
# # voucher=personal_voucher
# )
# Reminder.objects.create(
# username=name,
# email=email,
# from_email='Faye from Hook Coffee <*****@*****.**>',
# subject='',
# template_name='',
# scheduled=now + timedelta(days=14),
# # voucher=personal_voucher
# )
elif reason == "expensive":
if order_count < 3:
Reminder.objects.create(
username=name,
email=email,
from_email='Faye from Hook Coffee <*****@*****.**>',
subject='Just 24 hours remaining to claim a $6 discount',
template_name='React_Trial _TooExpensiveEmail1',
scheduled=now + timedelta(days=1),
)
else:
Reminder.objects.create(
username=name,
email=email,
from_email='Faye from Hook Coffee <*****@*****.**>',
subject='Just 24 hours remaining to claim a $6 discount',
template_name='React_Active _TooExpensiveEmail1',
scheduled=now + timedelta(days=1),
)
elif reason == "abroad":
# Reminder.objects.create(
# username=name,
# email=email,
# from_email='Faye from Hook Coffee <*****@*****.**>',
# subject='Want us to ship your order elsewhere {}?'.format(name),
# template_name='React_All_MovingAbroadEmail1',
# scheduled=now + timedelta(days=1),
# )
pass
elif reason in ["upset", "other"]:
Reminder.objects.create(
username=name,
email=email,
from_email='Faye from Hook Coffee <*****@*****.**>',
subject='What happened {}?'.format(name),
template_name='React_All_NoReasonEmail1',
scheduled=now + timedelta(days=1),
)
else:
Reminder.objects.create(
username=name,
email=email,
from_email='Faye from Hook Coffee <*****@*****.**>',
subject='What happened {}?'.format(name),
template_name='React_All_NoReasonEmail1',
scheduled=now + timedelta(days=1),
)
def test_message_generation(self):
"""
Make sure ReminderMessage objects are generated as expected.
"""
kwargs = {
'reminder_type': 'PERS',
'person': Person.objects.get(userid='ggbaker'),
'title': 'Test reminder',
'content': 'foo'
}
m, d = self._month_day_offset(
3) # near future: remindermessage should generate
r0 = Reminder(date_type='YEAR', month=m, day=d, **kwargs)
r0.save()
m, d = self._month_day_offset(
-30) # distant past: remindermessage should not generate
r1 = Reminder(date_type='YEAR', month=m, day=d, **kwargs)
r1.save()
m, d = self._month_day_offset(
90) # far future: remindermessage should not generate
r2 = Reminder(date_type='YEAR', month=m, day=d, **kwargs)
r2.save()
Reminder.create_all_reminder_messages()
rms = list(ReminderMessage.objects.all())
self.assertTrue(
len(rms) >= 1
) # may be other reminders from fixture objects, depending on run date
rm = rms[0]
self.assertEqual(rm.reminder, r0)
self.assertEqual(rm.sent, False)
ReminderMessage.send_all()
self.assertEqual(rm.sent, False) # shouldn't send: still in the future
