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_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 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 calculate_cost(self):
     """Calculate the cost of sending to this group."""
     try:
         cost = SiteConfiguration.get_twilio_settings()['sending_cost']
     except ConfigurationError:
         cost = 0
     return cost * self.all_recipients.count()

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 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 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 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 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 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 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 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 check_user_cost_limit(recipients, limit, msg):
     """Check the user has not exceeded their per SMS cost limit."""
     cost = SiteConfiguration.get_twilio_settings()['sending_cost']
     num_sms = ceil(len(msg) / 160)
     if limit == 0:
         return
     if limit < len(recipients) * cost * num_sms:
         raise ValidationError('Sorry, you can only send messages that cost no more than ${0}.'.format(limit))

 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 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 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': 'apostello', '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 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 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
            )
        )