def test_cleanup_expiry_date(self): config = SiteConfiguration.get_solo() config.sms_expiration_date = None config.save() logs.check_incoming_log() logs.check_outgoing_log() num_sms = models.SmsInbound.objects.count() + models.SmsOutbound.objects.count() logs.cleanup_expired_sms() assert num_sms > 0 assert models.SmsInbound.objects.count() + models.SmsOutbound.objects.count() == num_sms config = SiteConfiguration.get_solo() config.sms_expiration_date = today + timedelta(days=1) config.save() logs.cleanup_expired_sms() assert models.SmsInbound.objects.count() + models.SmsOutbound.objects.count() == 0
def test_cleanup_expired_sms(self, smsin): config = SiteConfiguration.get_solo() config.sms_expiration_date = None config.save() for sms in SmsInbound.objects.all(): # move back in time so they can be deleted sms.time_received = sms.time_received - timedelta(days=5) sms.save() cleanup_expired_sms() assert SmsInbound.objects.count() == len(smsin) config = SiteConfiguration.get_solo() config.sms_expiration_date = timezone.localdate() config.save() cleanup_expired_sms() assert SmsInbound.objects.count() == 0
def test_cleanup(self): # setup config = SiteConfiguration.get_solo() config.sms_rolling_expiration_days = None config.sms_expiration_date = today - timedelta(days=100) config.save() sms = models.SmsInbound.objects.create( content='test message', time_received=timezone.now() - timedelta(50), sender_name="John Calvin", sender_num="+447927401749", matched_keyword="test", sid='12345' ) sms.save() assert models.SmsInbound.objects.count() == 1 # we have one sms logs.cleanup_expired_sms() assert models.SmsInbound.objects.count() == 1 # cleanup should leave it untouched config.sms_rolling_expiration_days = 50 config.save() logs.cleanup_expired_sms() assert models.SmsInbound.objects.count() == 1 # cleanup should leave it untouched config.sms_rolling_expiration_days = 49 config.save() logs.cleanup_expired_sms() assert models.SmsInbound.objects.count() == 0 # cleanup should remove sms
def fetch_elvanto_groups(force=False): """Fetch all Elvanto groups.""" from site_config.models import SiteConfiguration config = SiteConfiguration.get_solo() if force or config.sync_elvanto: from elvanto.models import ElvantoGroup ElvantoGroup.fetch_all_groups()
def test_import_outgoing_rolling(self): config = SiteConfiguration.get_solo() config.sms_expiration_date = None config.sms_rolling_expiration_days = 0 config.save() logs.check_outgoing_log() assert models.SmsOutbound.objects.filter(time_sent__lt=today).count() == 0
def get_person_or_ask_for_name(from_, sms_body, keyword_obj): """ Return the Recipient object for the sender of the message. Perform a look up on the sender of the message. If they exist in the system, they are returned. Otherwise a message is queued to ask them for their name. """ try: person_from = Recipient.objects.get(number=from_) except Recipient.DoesNotExist: person_from = Recipient.objects.create( number=from_, first_name='Unknown', last_name='Person' ) person_from.save() if keyword_obj == "name": pass else: from site_config.models import SiteConfiguration config = SiteConfiguration.get_solo() if not config.disable_all_replies: person_from.send_message( content=fetch_default_reply('auto_name_request'), sent_by="auto name request" ) notify_office_mail.delay( '[Apostello] Unknown Contact!', 'SMS: {0}\nFrom: {1}\n\n\nThis person is unknown and has been asked for their name.'.format( sms_body, from_ ), ) return person_from
def pull_elvanto_groups(force=False): """Pull all the Elvanto groups that are set to sync.""" from site_config.models import SiteConfiguration config = SiteConfiguration.get_solo() if force or config.sync_elvanto: from elvanto.models import ElvantoGroup ElvantoGroup.pull_all_groups()
def global_settings(request): """Expose TWILIO_FROM_NUM, DEBUG and site config in templates.""" return { 'CONFIG': SiteConfiguration.get_solo(), 'DISPLAY_GOOGLE_LOGIN': SocialApp.objects.filter(provider='google').count(), 'ROLLBAR_ACCESS_TOKEN_CLIENT': settings.ROLLBAR_ACCESS_TOKEN_CLIENT, }
def recipient_send_message_task(recipient_pk, body, group, sent_by): """Send a message asynchronously.""" from apostello.models import Recipient from site_config.models import SiteConfiguration recipient = Recipient.objects.get(pk=recipient_pk) if recipient.is_archived: # if recipient is not active, fail silently return from apostello.models import SmsOutbound, RecipientGroup # if %name% is present, replace: body = recipient.personalise(body) # send twilio message try: message = get_twilio_client().messages.create( body=body, to=str(recipient.number), from_=str(SiteConfiguration.get_solo().twilio_from_num) ) # add to sms out table sms = SmsOutbound(sid=message.sid, content=body, time_sent=timezone.now(), recipient=recipient, sent_by=sent_by) if group is not None: sms.recipient_group = RecipientGroup.objects.filter(name=group)[0] sms.save() except TwilioRestException as e: if e.code == 21610: recipient.is_blocking = True recipient.save() async('apostello.tasks.blacklist_notify', recipient.pk, '', 'stop') else: raise e
def send_async_mail(subject, body, to): """Send email.""" # read email settings from DB from site_config.models import SiteConfiguration s = SiteConfiguration.get_solo() from_ = s.email_from send_mail(subject, body, from_, to)
def elm_settings(user): try: profile = user.profile except AttributeError: profile = UserProfile.nullProfile() config = SiteConfiguration.get_solo() try: twilio_settings = config.get_twilio_settings() # remove sensitive settings: del twilio_settings['auth_token'] del twilio_settings['sid'] except ConfigurationError: twilio_settings = None bk_key = f'blocked_keywords_user_{user.pk}' blocked_keywords = cache.get(bk_key) if blocked_keywords is None: blocked_keywords = [ x.keyword for x in Keyword.objects.all().prefetch_related('owners') if not x.can_user_access(user) ] cache.set(bk_key, blocked_keywords, 120) elm = { 'userPerms': UserProfileSerializer(profile).data, 'twilio': twilio_settings, 'isEmailSetup': config.is_email_setup(), 'smsCharLimit': config.sms_char_limit, 'defaultNumberPrefix': config.default_number_prefix, 'noAccessMessage': config.not_approved_msg, 'blockedKeywords': blocked_keywords, } return mark_safe(json.dumps(elm))
def global_settings(request): """Expose TWILIO_FROM_NUM, DEBUG and site config in templates.""" return { 'TWILIO_FROM_NUM': settings.TWILIO_FROM_NUM, 'TWILIO_SENDING_COST': settings.TWILIO_SENDING_COST, 'DEBUG': settings.DEBUG, 'CONFIG': SiteConfiguration.get_solo(), }
def send_async_mail(subject, body, to): """Send email.""" # read email settings from DB, if they are empty, they will be read from # settings.py instead from site_config.models import SiteConfiguration s = SiteConfiguration.get_solo() from_ = s.email_from or settings.EMAIL_FROM send_mail(subject, body, from_, to)
def __init__(self, *args, **kwargs): super(ApostelloEmailBackend, self).__init__(*args, **kwargs) from site_config.models import SiteConfiguration s = SiteConfiguration.get_solo() self.host = s.email_host self.port = s.email_port self.username = s.email_username self.password = s.email_password
def test_no_name_raises(self): """Test shorter limit imposed with %name% present.""" s = SiteConfiguration.get_solo() with pytest.raises(ValidationError): less_than_sms_char_limit( 't %name%' * (s.sms_char_limit - settings.MAX_NAME_LENGTH + len('%name%')) )
def post_to_slack(attachments): """Post message to slack webhook.""" from site_config.models import SiteConfiguration config = SiteConfiguration.get_solo() url = config.slack_url if url: data = {'username': '******', 'icon_emoji': ':speech_balloon:', 'attachments': attachments} headers = {'Content-type': 'application/json', 'Accept': 'text/plain'} requests.post(url, data=json.dumps(data), headers=headers)
def global_settings(request): """Expose TWILIO_FROM_NUM, DEBUG and site config in templates.""" return { 'TWILIO_FROM_NUM': settings.TWILIO_FROM_NUM, 'TWILIO_SENDING_COST': settings.TWILIO_SENDING_COST, 'DEBUG': settings.DEBUG, 'CONFIG': SiteConfiguration.get_solo(), 'DISPLAY_GOOGLE_LOGIN': SocialApp.objects.filter(provider='google').count(), }
def test_get_email(): """Test pulling email from settings and SiteConfiguration.""" s = SiteConfiguration.get_solo() a = ApostelloAccountAdapter() # test env var is migrated into db: assert s.email_from == '*****@*****.**' assert a.get_from_email() == '*****@*****.**' # test change in db s.email_from = '*****@*****.**' s.save() assert a.get_from_email() == '*****@*****.**'
def less_than_sms_char_limit(value): """Ensure message is less than the maximum character limit.""" from site_config.models import SiteConfiguration s = SiteConfiguration.get_solo() sms_char_lim = s.sms_char_limit - settings.MAX_NAME_LENGTH + len('%name%') if len(value) > sms_char_lim: raise ValidationError( 'You have exceeded the maximum char limit of {0}.'.format( sms_char_lim ) )
def setup_twilio(): config = SiteConfiguration.get_solo() config.twilio_account_sid = os.environ.get('TWILIO_ACCOUNT_SID') config.twilio_auth_token = os.environ.get('TWILIO_AUTH_TOKEN') config.twilio_from_num = os.environ.get('TWILIO_FROM_NUM') try: cost = float(os.environ.get('TWILIO_SENDING_COST')) except TypeError: cost = None config.twilio_sending_cost = cost config.save()
def test_get_email(): """Test pulling email from settings and SiteConfiguration.""" s = SiteConfiguration.get_solo() a = ApostelloAccountAdapter() # test env var is migrated into db: assert s.email_from == "*****@*****.**" assert a.get_from_email() == "*****@*****.**" # test change in db s.email_from = "*****@*****.**" s.save() assert a.get_from_email() == "*****@*****.**"
def add_new_contact_to_groups(contact_pk): """Add contact to any groups that are in "auto populate with new contacts.""" logger.info('Adding new person to designated groups') from apostello.models import Recipient from site_config.models import SiteConfiguration contact = Recipient.objects.get(pk=contact_pk) for grp in SiteConfiguration.get_solo().auto_add_new_groups.all(): logger.info('Adding %s to %s', contact.full_name, grp.name) contact.groups.add(grp) contact.save() logger.info('Added %s to %s', contact.full_name, grp.name)
def test_handle_outgoing_sms(self): config = SiteConfiguration.get_solo() config.sms_expiration_date = None config.save() msg = MockMsg("447932537999") cnp = logs.handle_outgoing_sms(msg) assert models.SmsOutbound.objects.all()[0].content == msg.body assert models.SmsOutbound.objects.count() == 1 logs.handle_outgoing_sms(msg) assert models.SmsOutbound.objects.count() == 1
def add_new_contact_to_groups(contact_pk): """Add contact to any groups that are in "auto populate with new contacts.""" logger.info("Adding new person to designated groups") from apostello.models import Recipient from site_config.models import SiteConfiguration contact = Recipient.objects.get(pk=contact_pk) for grp in SiteConfiguration.get_solo().auto_add_new_groups.all(): logger.info("Adding %s to %s", contact.full_name, grp.name) contact.groups.add(grp) contact.save() logger.info("Added %s to %s", contact.full_name, grp.name)
def cleanup_expired_sms(): """Remove expired messages.""" config = SiteConfiguration.get_solo() if config.sms_expiration_date is None: # no expiration, skip checks return for sms in SmsInbound.objects.filter( time_received__date__lt=config.sms_expiration_date): sms.delete() for sms in SmsOutbound.objects.filter( time_sent__date__lt=config.sms_expiration_date): sms.delete()
def less_than_sms_char_limit(value): """Ensure message is less than the maximum character limit.""" from site_config.models import SiteConfiguration s = SiteConfiguration.get_solo() sms_char_lim = s.sms_char_limit if '%name%' in value: # if `%name%` in value, then adjust limit to handle substitutions sms_char_lim = sms_char_lim - settings.MAX_NAME_LENGTH + len('%name%') if len(value) > sms_char_lim: raise ValidationError('You have exceeded the maximum char limit of {0}.'.format(sms_char_lim))
def test_apostello_mail_backend(): """Test email backend pulling from settings and db.""" # test migration pulled env var mail_backend = ApostelloEmailBackend() assert mail_backend.host == 'smtp.test.apostello' # test Siteconfiguration change s = SiteConfiguration.get_solo() s.get_solo() s.email_host = 'smtp.test2.apostello' s.save() mail_backend = ApostelloEmailBackend() assert mail_backend.host == 'smtp.test2.apostello'
def test_not_logged_in(self, keywords, recipients): # make sure replies are on: from site_config.models import SiteConfiguration config = SiteConfiguration.get_solo() config.disable_all_replies = False config.save() factory = TwilioRequestFactory(token=settings.TWILIO_AUTH_TOKEN) data = test_request_data_blocked() data['Body'] = u'Test' request = factory.post(uri, data=data) resp = sms(request) assert '<Message><Body /></Message>' in str(resp.content)
def test_handle_outgoing_sms(self): config = SiteConfiguration.get_solo() config.sms_expiration_date = None config.save() msg = MockMsg('447932537999') cnp = logs.handle_outgoing_sms(msg) assert models.SmsOutbound.objects.all()[0].content == msg.body assert models.SmsOutbound.objects.count() == 1 logs.handle_outgoing_sms(msg) assert models.SmsOutbound.objects.count() == 1
def test_not_logged_in(self, keywords, recipients): # make sure replies are on: from site_config.models import SiteConfiguration config = SiteConfiguration.get_solo() config.disable_all_replies = False config.save() factory = TwilioRequestFactory(token=settings.TWILIO_AUTH_TOKEN) data = test_request_data_blocked() data['Body'] = u'Test' request = factory.post(uri, data=data) resp = sms(request) assert '<Response />' in str(resp.content)
def test_twilio_view(msg, reply, keywords, recipients): # make sure replies are on: from site_config.models import SiteConfiguration config = SiteConfiguration.get_solo() config.disable_all_replies = False config.save() factory = TwilioRequestFactory(token=settings.TWILIO_AUTH_TOKEN) data = test_request_data() data['Body'] = msg request = factory.post(uri, data=data) resp = sms(request) assert reply in str(resp.content)
def test_get_email(): """Test pulling email from settings and SiteConfiguration.""" s = SiteConfiguration.get_solo() a = ApostelloAccountAdapter() # test from db s.email_from = '*****@*****.**' s.save() assert a.get_from_email() == '*****@*****.**' # test from settings s.email_from = '' s.save() assert a.get_from_email() == '*****@*****.**'
def test_handle_incoming_sms(self): config = SiteConfiguration.get_solo() config.sms_expiration_date = None config.save() msg = MockMsg('447922537999') logs.handle_incoming_sms(msg) assert models.SmsInbound.objects.all()[0].content == msg.body assert models.SmsInbound.objects.count() == 1 cnp = logs.handle_incoming_sms(msg) assert models.SmsInbound.objects.count() == 1
def test_twilio_view_blocking_contact(keywords, recipients): # make sure replies are on: from site_config.models import SiteConfiguration config = SiteConfiguration.get_solo() config.disable_all_replies = False config.save() factory = TwilioRequestFactory(token=get_token()) data = test_request_data_blocked() data["Body"] = "Test" request = factory.post(uri, data=data) resp = sms(request) assert "<Response />" in str(resp.content)
def test_not_logged_in(self, msg, reply, keywords): factory = TwilioRequestFactory(token=settings.TWILIO_AUTH_TOKEN) data = test_request_data() data['Body'] = msg request = factory.post(uri, data=data) # turn off responses from site_config.models import SiteConfiguration config = SiteConfiguration.get_solo() config.disable_all_replies = True config.save() # run test resp = sms(request) assert reply not in str(resp.content)
def post_to_slack(attachments): """Post message to slack webhook.""" from site_config.models import SiteConfiguration config = SiteConfiguration.get_solo() url = config.slack_url if url: data = { 'username': '******', 'icon_emoji': ':speech_balloon:', 'attachments': attachments } headers = {'Content-type': 'application/json', 'Accept': 'text/plain'} requests.post(url, data=json.dumps(data), headers=headers)
def test_default_prefix(self, live_server, browser_in, users, driver_wait_time): """Test prefix shows on form.""" from site_config.models import SiteConfiguration config = SiteConfiguration.get_solo() config.default_number_prefix = '+45' config.save() b = load_page(browser_in, driver_wait_time, live_server + URI) assert 'value="+45"' in b.page_source config.default_number_prefix = '' config.save() b = load_page(browser_in, driver_wait_time, live_server + URI) assert 'value="+45"' not in b.page_source
def less_than_sms_char_limit(value): """Ensure message is less than the maximum character limit.""" from site_config.models import SiteConfiguration s = SiteConfiguration.get_solo() sms_char_lim = s.sms_char_limit if "%name%" in value: # if `%name%` in value, then adjust limit to handle substitutions sms_char_lim = sms_char_lim - settings.MAX_NAME_LENGTH + len("%name%") if len(value) > sms_char_lim: raise ValidationError("You have exceeded the maximum char limit of {0}.".format(sms_char_lim))
def email_admin_on_signup(request, user, **kwargs): """Email office on new user sign up.""" body = ( "New User Signed Up: {}\n\n" "Please go to the admin page to approve their account.\n" "If you do not approve their account (and they are not using a " "whitelisted domain), they will be unable to access apostello." ) body = body.format(str(user)) from site_config.models import SiteConfiguration to_ = SiteConfiguration.get_solo().office_email if to_: send_async_mail("[apostello] New User", body, [to_], )
def test_add_new_ppl_to_groups(self, groups): config = SiteConfiguration.get_solo() grp = groups['empty_group'] assert grp.recipient_set.count() == 0 config.auto_add_new_groups.add(grp) config.save() new_c = Recipient.objects.create( first_name='test', last_name='new', number='+44715620857', ) assert grp.recipient_set.count() == 1 assert new_c in grp.recipient_set.all()
def test_twilio_view_no_replies(msg, reply, keywords): factory = TwilioRequestFactory(token=get_token()) data = test_request_data() data["Body"] = msg request = factory.post(uri, data=data) # turn off responses from site_config.models import SiteConfiguration config = SiteConfiguration.get_solo() config.disable_all_replies = True config.save() # run test resp = sms(request) assert reply not in str(resp.content)
def test_not_logged_in(self, keywords): # make sure replies are on: from site_config.models import SiteConfiguration config = SiteConfiguration.get_solo() config.disable_all_replies = False config.save() factory = TwilioRequestFactory(token=settings.TWILIO_AUTH_TOKEN) data = test_request_data() data['Body'] = u'Test' request = factory.post(uri, data=data) resp = sms(request) assert 'Unknown' in str(resp.content) assert len(mail.outbox) == 1 assert 'asked for their name' in mail.outbox[0].body
def test_apostello_mail_backend(): """Test email backend pulling from settings and db.""" # get from Siteconfiguration s = SiteConfiguration.get_solo() s.get_solo() s.email_host = 'smtp.test2.apostello' s.save() mail_backend = ApostelloEmailBackend() assert mail_backend.host == 'smtp.test2.apostello' # get from settings s.email_host = '' s.save() mail_backend = ApostelloEmailBackend() assert mail_backend.host == 'smtp.test.apostello'
def test_sms_too_long(self, live_server, browser_in, users, driver_wait_time, recipients): """Test form submission with a message that is too long.""" from site_config.models import SiteConfiguration s = SiteConfiguration.get_solo() s.sms_char_limit = 2 s.save() b = load_page(browser_in, driver_wait_time, live_server + ADHOC_URI) b = add_content_and_recipient(b, driver_wait_time) b = click_send(b, driver_wait_time) assert 'You have exceeded' in b.page_source assert ADHOC_URI in b.current_url s.sms_char_limit = 200 s.save()
def test_default_prefix( self, live_server, browser_in, users, driver_wait_time ): """Test prefix shows on form.""" from site_config.models import SiteConfiguration config = SiteConfiguration.get_solo() config.default_number_prefix = '+45' config.save() b = load_page(browser_in, driver_wait_time, live_server + URI) assert '+45' in b.page_source config.default_number_prefix = '' config.save() b = load_page(browser_in, driver_wait_time, live_server + URI) assert '+45' not in b.page_source
def email_admin_on_signup(request, user, **kwargs): """Email office on new user sign up.""" body = ("New User Signed Up: {}\n\n" "Please go to the admin page to approve their account.\n" "If you do not approve their account (and they are not using a " "whitelisted domain), they will be unable to access apostello.") body = body.format(str(user)) from site_config.models import SiteConfiguration to_ = SiteConfiguration.get_solo().office_email if to_: send_async_mail( "[apostello] New User", body, [to_], )
def test_twilio_view_ask_for_name(keywords): # make sure replies are on: from site_config.models import SiteConfiguration config = SiteConfiguration.get_solo() config.disable_all_replies = False config.office_email = "*****@*****.**" config.save() factory = TwilioRequestFactory(token=get_token()) data = test_request_data() data["Body"] = "Test" request = factory.post(uri, data=data) resp = sms(request) assert "Unknown" not in str(resp.content) assert "Thanks new person!" in str(resp.content) assert len(mail.outbox) == 1 assert "asked for their name" in mail.outbox[0].body
def ask_for_name(person_from_pk, sms_body, ask_for_name): """Asks a contact to provide their name.""" if not ask_for_name: return from site_config.models import SiteConfiguration config = SiteConfiguration.get_solo() if not config.disable_all_replies: from apostello.models import Recipient contact = Recipient.objects.get(pk=person_from_pk) contact.send_message(content=fetch_default_reply('auto_name_request'), sent_by="auto name request") async ( 'apostello.tasks.notify_office_mail', '[Apostello] Unknown Contact!', 'SMS: {0}\nFrom: {1}\n\n\nThis person is unknown and has been' ' asked for their name.'.format(sms_body, str(contact)), )
def sms(request): """ Handle all incoming messages from Twilio. This is the start of the message processing pipeline. """ logger.info('Received new sms') r = twiml.Response() msg = InboundSms(request.POST) msg.start_bg_tasks() config = SiteConfiguration.get_solo() if msg.reply and not config.disable_all_replies: logger.info('Add reply (%s) to response', msg.reply) r.message(msg.reply) logger.info('Return response to Twilio') return r
def sms(request): """ Handle all incoming messages from Twilio. This is the start of the message processing pipeline. """ logger.info("Received new sms") r = MessagingResponse() msg = InboundSms(request.POST) msg.start_bg_tasks() config = SiteConfiguration.get_solo() if msg.reply and not config.disable_all_replies: logger.info("Add reply (%s) to response", msg.reply) r.message(msg.reply) logger.info("Return response to Twilio") return HttpResponse(str(r), content_type="application/xml")
def email_admin_on_signup(request, user, **kwargs): """Email office on new user sign up.""" body = ("New User Signed Up: {}\n\n" "Please go to the admin page to approve their account.\n" "If you do not approve their account (and they are not using a " "whitelisted domain), they will be unable to access apostello.") body = body.format(str(user)) from site_config.models import SiteConfiguration to_ = SiteConfiguration.get_solo().office_email try: if len(to_) > 0: send_mail( "[apostello] New User", body, '', [to_], ) except Exception: logger.error('Error sending email to office on new user sign up', exc_info=True)
def test_sign_up(self, live_server, browser, driver_wait_time, users): """ Tests the sign up form and checks that the appropriate emails have been sent afterwards. """ # add an office email to test correct email is sent on sign up config = SiteConfiguration.get_solo() config.office_email = '*****@*****.**' config.save() # signup uri = '/accounts/signup/' browser.get(live_server + uri) email_box = browser.find_elements_by_name('email')[0] email_box.send_keys('*****@*****.**') password_box1 = browser.find_elements_by_name('password1')[0] password_box1.send_keys('top_secret') password_box2 = browser.find_elements_by_name('password2')[0] password_box2.send_keys('top_secret') login_button = browser.find_element_by_id('signupButton') login_button.click() def _test(): assert '/accounts/confirm-email/' in browser.current_url assert len(mail.outbox) == 2 assert '[apostello] New User' in mail.outbox[0].subject assert_with_timeout(_test, 10 * driver_wait_time) # when we have no office email set assert 'Please Confirm Your E-mail Address' in mail.outbox[1].subject for x in mail.outbox[1].body.split(): if x.startswith('http'): confirm_url = x browser.get(confirm_url) confirm_button = browser.find_element_by_id('confirmButton') confirm_button.click() user = User.objects.get(email='*****@*****.**') assert not user.is_staff assert not user.is_superuser
def sms(request): """ Handle all incoming messages from Twilio. This is the start of the message processing pipeline. """ r = twiml.Response() params = request.POST from_ = params['From'] sms_body = params['Body'].strip() keyword_obj = Keyword.match(sms_body) # get person object and optionally ask for their name person_from = get_person_or_ask_for_name(from_, sms_body, keyword_obj) log_msg_in.delay(params, timezone.now(), person_from.pk) sms_to_slack.delay(sms_body, person_from, keyword_obj) reply = reply_to_incoming(person_from, from_, sms_body, keyword_obj) config = SiteConfiguration.get_solo() if not config.disable_all_replies: r.message(reply) return r
def test_first_user_sign_up(self, live_server, browser): """ Tests the sign up form and checks that the appropriate emails have been sent afterwards. Then we confirm the email and verify the user has been made an admin. """ # add an office email to test correct email is sent on sign up config = SiteConfiguration.get_solo() config.office_email = '*****@*****.**' config.save() # signup uri = '/accounts/signup' browser.get(live_server + uri) email_box = browser.find_elements_by_name('email')[0] email_box.send_keys('*****@*****.**') password_box1 = browser.find_elements_by_name('password1')[0] password_box1.send_keys('top_secret') password_box2 = browser.find_elements_by_name('password2')[0] password_box2.send_keys('top_secret') login_button = browser.find_elements_by_xpath( 'html/body/div/div/form/button' )[0] login_button.click() # check we have been redirected assert '/accounts/confirm-email/' in browser.current_url assert len(mail.outbox) == 2 assert '[apostello] New User' in mail.outbox[0].subject assert 'Please Confirm Your E-mail Address' in mail.outbox[1].subject for x in mail.outbox[1].body.split(): if x.startswith('http'): confirm_url = x browser.get(confirm_url) confirm_button = browser.find_element_by_class_name('button') confirm_button.click() user = User.objects.get(email='*****@*****.**') assert user.is_staff assert user.is_superuser
def test_no_name_raises(self): """Test raises error with no %name% sub.""" s = SiteConfiguration.get_solo() with pytest.raises(ValidationError): less_than_sms_char_limit('t' * (s.sms_char_limit + 1))