Esempio n. 1
0
    def send_activation_email(self, domain=None, resend=False, template=None, subject=None, sender=None):
        """Sends an activation email
        """
        domain = domain or htk_setting('HTK_DEFAULT_EMAIL_SENDING_DOMAIN')
        self._reset_activation_key(resend=resend)

        try:
            should_send_activation_email = True

            if htk_setting('HTK_ITERABLE_ENABLED'):
                from htk.lib.iterable.utils import get_iterable_api_client
                from htk.lib.iterable.utils import get_campaign_id

                if resend:
                    campaign_key = 'triggered.transactional.account.confirm_email_resend'
                else:
                    campaign_key = 'triggered.transactional.account.sign_up_confirm_email'
                itbl_campaign_id = get_campaign_id(campaign_key)

                if itbl_campaign_id:
                    should_send_activation_email = False

                    data = {
                        'activation_uri' : self.get_activation_uri(domain=domain),
                    }

                    itbl = get_iterable_api_client()
                    itbl.send_triggered_email(self.email, itbl_campaign_id, data=data)

            if should_send_activation_email:
                activation_email(self, domain=domain, template=template, subject=subject, sender=sender)
        except:
            request = get_current_request()
            rollbar.report_exc_info(request=request)
Esempio n. 2
0
def activation_email(user_email, use_https=False, domain=None, template=None, subject=None):
    """Sends an activation/confirmation email for user to confirm email address
    """
    user = user_email.user
    email = user_email.email
    domain = domain or htk_setting('HTK_DEFAULT_EMAIL_SENDING_DOMAIN')

    context = {
        'user': user,
        'email': email,
        'protocol': use_https and 'https' or 'http', 
        'domain': domain,
        'site_name': htk_setting('HTK_SITE_NAME'),
        'confirm_email_path': reverse(
            htk_setting('HTK_ACCOUNTS_CONFIRM_EMAIL_URL_NAME'),
            args=(user_email.activation_key,)
        ),
    }

    if template is None:
        template='accounts/activation'

    if subject is None:
        subject = 'Confirm your email address, %s' % email

    activation_uri = '%(protocol)s://%(domain)s%(confirm_email_path)s' % context
    context['activation_uri'] = activation_uri
    bcc = htk_setting('HTK_DEFAULT_EMAIL_BCC')
    send_email(
        template=template,
        subject=subject,
        to=[email,],
        context=context,
        bcc=bcc
    )
Esempio n. 3
0
def create_user_profile(sender, instance, created, **kwargs):
    """signal handler for User post-save
    """
    if created:
        user = instance
        from htk.apps.accounts.utils.general import get_user_profile_model
        UserProfileModel = get_user_profile_model()
        profile = UserProfileModel.objects.create(user=user)
        profile.save()
        if not settings.TEST and htk_setting('HTK_SLACK_NOTIFICATIONS_ENABLED'):
            try:
                from htk.utils.notifications import slack_notify
                slack_notify('A new user has registered on the site %s: *%s <%s>*' % (
                    get_site_name(),
                    user.profile.get_display_name(),
                    user.email,
                ))
                if htk_setting('HTK_SLACK_BOT_ENABLED'):
                    slack_notify('htk: emaildig %s' % user.email)
            except:
                rollbar.report_exc_info()

        if not settings.TEST and htk_setting('HTK_ITERABLE_ENABLED'):
            try:
                from htk.lib.iterable.utils import get_iterable_api_client
                itbl = get_iterable_api_client()
                itbl.notify_sign_up(user)
            except:
                rollbar.report_exc_info()

        if htk_setting('HTK_INVITATIONS_LIFECYCLE_SIGNALS_ENABLED'):
            from htk.apps.invitations.services import InvitationsService
            invitations_service = InvitationsService()
            invitations_service.process_user_created(user)
def check_email(request, details, user=None, *args, **kwargs):
    """Ask the user to enter the email if we don't have one yet

    The pipeline process was cut prior to this custom pipeline function, and will resume to this same function after completing
    """
    response = None
    if user is None:
        social_email = details.get('email')
        collected_email = request.session.get(SOCIAL_REGISTRATION_SETTING_EMAIL)
        if social_email:
            # email available from social auth
            user = get_user_by_email(social_email)
            if user and user.is_active:
                # a user is already associated with this email
                # TODO: there is an error with linking accounts...
                request.session[SOCIAL_REGISTRATION_SETTING_EMAIL] = social_email
                if user.has_usable_password():
                    # user should log into the existing account with a password
                    url_name = htk_setting('HTK_ACCOUNTS_REGISTER_SOCIAL_LOGIN_URL_NAME')
                else:
                    # no password was set, so user must log in with another social auth account
                    url_name = htk_setting('HTK_ACCOUNTS_REGISTER_SOCIAL_ALREADY_LINKED_URL_NAME')
                response = redirect(url_name)
        elif collected_email:
            # email provided by user
            details['email'] = collected_email
            response = { 'details' : details }
        else:
            # no email provided from social auth
            request.session[SOCIAL_REGISTRATION_SETTING_MISSING_EMAIL] = True
            url_name = htk_setting('HTK_ACCOUNTS_REGISTER_SOCIAL_EMAIL_URL_NAME')
            response = redirect(url_name)

    return response
Esempio n. 5
0
def send_markdown_email(
    subject='',
    sender=None,
    to=None,
    cc=None,
    bcc=None,
    markdown_content=''
):
    """Sends an email  w/ text and HTML produced from Markdown
    """
    sender = sender or htk_setting('HTK_DEFAULT_EMAIL_SENDER', HTK_DEFAULT_EMAIL_SENDER)
    to = to or htk_setting('HTK_DEFAULT_EMAIL_RECIPIENTS', HTK_DEFAULT_EMAIL_RECIPIENTS)
    bcc = bcc or []
    cc = cc or []

    if settings.ENV_DEV:
        subject = '[%s-dev] %s' % (htk_setting('HTK_SYMBOLIC_SITE_NAME'), subject,)

    msg = EmailMultiAlternatives(subject=subject,
                                 body=markdown_content,
                                 from_email=sender,
                                 to=to,
                                 bcc=bcc,
                                 cc=cc)

    import markdown
    html_content = markdown.markdown(markdown_content)
    msg.attach_alternative(html_content, 'text/html')
    msg.send()
Esempio n. 6
0
def email_context_generator():
    """Default HTK email context generator
    Returns a dictionary with values for inflating templated emails
    """
    request = get_current_request()
    protocol = 'http'
    if request:
        if request.is_secure():
            protocol = 'https'
        else:
            pass
        domain = request.get_host() or htk_setting('HTK_DEFAULT_DOMAIN')
    else:
        domain = htk_setting('HTK_DEFAULT_DOMAIN')

    base_url = '%(protocol)s://%(domain)s' % {
        'protocol' : protocol,
        'domain' : domain,
    }

    context = {
        'base_url': base_url,
        'site_name': htk_setting('HTK_SITE_NAME'),
        'support_email': htk_setting('HTK_SUPPORT_EMAIL'),
    }
    return context
Esempio n. 7
0
    def save(self, domain=None, email_template=None, email_subject=None, email_sender=None, commit=True):
        domain = domain or htk_setting('HTK_DEFAULT_EMAIL_SENDING_DOMAIN')
        user = super(NameEmailUserRegistrationForm, self).save(commit=False)
        email = self.email
        # temporarily assign a unique username so that we can create the record and the user can log in
        if htk_setting('HTK_ACCOUNTS_REGISTER_SET_PRETTY_USERNAME_FROM_EMAIL', False):
            user.username = email_to_username_pretty_unique(email)
        else:
            user.username = email_to_username_hash(email)
        #password1 = self.cleaned_data.get('password1')
        #user.set_password(password1)
        if commit:
            user.save()
            # associate user and email
            from htk.apps.accounts.utils import associate_user_email
            user_email = associate_user_email(user, email, domain=domain, email_template=email_template, email_subject=email_subject, email_sender=email_sender)
            # mark has_username_set
            user_profile = user.profile
            user_profile.has_username_set = True
            user_profile.save()

            # send welcome email
            was_activated = user.is_active
            if was_activated:
                user_profile.send_welcome_email()
        return user
Esempio n. 8
0
def email_context_generator():
    """Dummy email context generator
    Returns a dictionary
    """
    request = GlobalRequestMiddleware.get_current_request()
    protocol = 'http'
    if request:
        if request.is_secure():
            protocol = 'https'
        else:
            pass
        domain = request.get_host() or htk_setting('HTK_DEFAULT_DOMAIN')
    else:
        domain = htk_setting('HTK_DEFAULT_DOMAIN')

    base_url = '%(protocol)s://%(domain)s' % {
        'protocol' : protocol,
        'domain' : domain,
    }

    context = {
        'base_url': base_url,
        'site_name': htk_setting('HTK_SITE_NAME'),
    }
    return context
Esempio n. 9
0
def get_shopify_api_cli(shop_name=None, api_key=None, api_secret=None):
    from htk.lib.shopify_lib.api import HtkShopifyAPIClient
    shop_name = shop_name if shop_name else htk_setting('HTK_SHOPIFY_SHOP_NAME')
    api_key = api_key if api_key else htk_setting('HTK_SHOPIFY_API_KEY')
    api_secret = api_secret if api_secret else htk_setting('HTK_SHOPIFY_API_SECRET')
    api = HtkShopifyAPIClient(shop_name=shop_name, api_key=api_key, api_secret=api_secret)
    return api
Esempio n. 10
0
    def send_activation_reminder_email(self):
        """Sends an account activation reminder email

        Piggybacks off of `self.send_activation_email`
        """
        template = htk_setting('HTK_ACCOUNT_ACTIVATION_REMINDER_EMAIL_TEMPLATE')
        subject = 'Reminder to activate your account on %s' % htk_setting('HTK_SITE_NAME')
        self.send_activation_email(resend=True, template=template, subject=subject)
Esempio n. 11
0
def get_event_handler(event_type):
    event_handlers = htk_setting('HTK_ZUORA_EVENT_HANDLERS')
    event_type = event_type if event_type in event_handlers else 'default' if htk_setting('HTK_ZUORA_HANDLE_UNHANDLED_EVENTS') else None
    event_handler_module = event_handlers.get(event_type)
    if event_handler_module:
        event_handler = resolve_method_dynamically(event_handler_module)
    else:
        event_handler = None
    return event_handler
Esempio n. 12
0
def get_event_handler_usages(event):
    event_handler_usages = copy.copy(htk_setting('HTK_SLACK_EVENT_HANDLER_USAGES'))
    webhook_settings = event.get('webhook_settings', {})

    # add in additional event group handler usages
    extra_event_handler_usages = htk_setting('HTK_SLACK_EVENT_HANDLER_USAGES_EXTRA')
    for event_group, usages in extra_event_handler_usages.iteritems():
        if webhook_settings.get(event_group, False) is True:
            event_handler_usages.update(usages)
    return event_handler_usages
Esempio n. 13
0
    def __init__(self, mongodb_connection=None, mongodb_name=None, api=None):
        if mongodb_connection is None:
            self.mongodb_connection = htk_setting('HTK_MONGODB_CONNECTION')
        else:
            self.mongodb_connection = mongodb_connection
        if mongodb_name is None:
            self.mongodb_name = htk_setting('HTK_MONGODB_NAME')
        else:
            self.mongodb_name = mongodb_name

        self.mongodb_initialized = False
        super(HtkShopifyMongoDBArchiver, self).__init__(api=api)
Esempio n. 14
0
def set_input_placeholder_labels(form):
    """Set placeholder attribute to the field label on form input fields, if it doesn't have a placeholder set
    """
    if htk_setting('HTK_FORMS_USE_CUSTOM_PLACEHOLDER_VALUES'):
        custom_labels = htk_setting('HTK_FORMS_CUSTOM_PLACEHOLDER_VALUES')
    else:
        custom_labels = {}

    for name, field in form.fields.items():
        if field.widget.__class__ in TEXT_STYLE_INPUTS:
            if not field.widget.attrs.get('placeholder'):
                placeholder_value = custom_labels.get(name, field.label)
                field.widget.attrs['placeholder'] = placeholder_value
Esempio n. 15
0
def password_changed_email(user):
    context = {
        'user': user,
        'email': user.email,
        'domain': htk_setting('HTK_DEFAULT_DOMAIN'),
        'site_name': htk_setting('HTK_SITE_NAME'),
    }
    send_email(
        template='accounts/password_changed',
        subject='Password changed on %s' % context['site_name'],
        to=[user.email],
        context=context
    )
Esempio n. 16
0
def is_dev_host(host):
    """Determines whether `host` is a dev host
    """
    canonical_domain = htk_setting('HTK_CANONICAL_DOMAIN')
    dev_host_regexps = htk_setting('HTK_DEV_HOST_REGEXPS')
    is_dev = False
    for r in dev_host_regexps:
        if re.match(r'%s%s' % (r, canonical_domain,), host):
            is_dev = True
            break
        else:
            pass
    return is_dev
Esempio n. 17
0
def welcome_email(user):
    context = {
        'user': user,
        'site_name': htk_setting('HTK_SITE_NAME'),
    }
    bcc = htk_setting('HTK_DEFAULT_EMAIL_BCC')
    send_email(
        template='accounts/welcome',
        subject='Welcome to %s, %s' % (htk_setting('HTK_SITE_NAME'), user.email,),
        to=[user.email],
        context=context,
        bcc=bcc
    )
Esempio n. 18
0
    def get_activation_uri(self, use_https=False, domain=None):
        domain = domain or htk_setting('HTK_DEFAULT_EMAIL_SENDING_DOMAIN')

        values = {
            'protocol' : 'https' if use_https else 'http',
            'domain' : domain,
            'confirm_email_path' : reverse(
                htk_setting('HTK_ACCOUNTS_CONFIRM_EMAIL_URL_NAME'),
                args=(self.activation_key,)
            ),
        }
        activation_uri = '%(protocol)s://%(domain)s%(confirm_email_path)s' % values
        return activation_uri
Esempio n. 19
0
def get_event_handlers(event):
    """Gets all the event handlers available for `event`

    Specifically, this is the set of event handlers in
      {HTK_ALEXA_SKILL_EVENT_HANDLERS}
    """
    event_handlers = copy.copy(htk_setting('HTK_ALEXA_SKILL_EVENT_HANDLERS'))

    # add in additional event group handlers
    extra_event_handlers = htk_setting('HTK_ALEXA_SKILL_EVENT_HANDLERS_EXTRAS')
    for event_group, handlers in extra_event_handlers.iteritems():
        event_handlers.update(handlers)

    return event_handlers
Esempio n. 20
0
def create_user_profile(sender, instance, created, **kwargs):
    """signal handler for User post-save
    """
    if created:
        user = instance
        UserProfileModel = get_user_profile_model()
        profile = UserProfileModel.objects.create(user=user)
        profile.save()
        if htk_setting('HTK_SLACK_NOTIFICATIONS_ENABLED'):
            slack_notify('A new user has registered on the site %s: *%s <%s>*' % (
                htk_setting('HTK_SITE_NAME'),
                user.profile.get_display_name(),
                user.email,
            ))
Esempio n. 21
0
def password_changed_email(user):
    context = {
        'user': user,
        'email': user.email,
        'domain': htk_setting('HTK_DEFAULT_DOMAIN'),
        'site_name': htk_setting('HTK_SITE_NAME'),
    }
    subject = htk_setting('HTK_ACCOUNT_EMAIL_SUBJECT_PASSWORD_CHANGED') % context
    send_email(
        template='accounts/password_changed',
        subject=subject,
        to=[user.email],
        context=context
    )
Esempio n. 22
0
def slack_notify(message, level=None):
    """Send a Slack notification message

    `level` is one of ['critical', 'severe', 'danger', 'warning', 'info', 'debug',]
    """
    from htk.lib.slack.utils import webhook_call as slack_webhook_call
    try:
        channels = htk_setting('HTK_SLACK_NOTIFICATION_CHANNELS')
        default_level = 'debug' if (settings.ENV_DEV or settings.TEST) else 'info'
        level = level if level in channels else default_level
        channel = channels.get(level, htk_setting('HTK_SLACK_DEBUG_CHANNEL'))
        slack_webhook_call(text=message, channel=channel)
    except:
        request = get_current_request()
        rollbar.report_exc_info(request=request)
Esempio n. 23
0
def log_event(event, request=None, log_level='info', message=None):
    """Log the Stripe event `event`
    """
    live_mode = event.get('livemode', False)
    should_log = live_mode or htk_setting('HTK_STRIPE_LOG_TEST_MODE_EVENTS')
    if should_log:
        logger_type = htk_setting('HTK_STRIPE_EVENT_LOGGER')
        if logger_type == 'rollbar':
            _log_event_rollbar(event, request=None, log_level='info', message=None)
        else:
            # unrecognized Stripe event logger
            pass
    else:
        # do nothing
        pass
Esempio n. 24
0
def simple_email(
    subject='',
    message='',
    sender=None,
    to=None,
    fail_silently=False
):
    """Sends a simple email
    """
    sender = sender or htk_setting('HTK_DEFAULT_EMAIL_SENDER', HTK_DEFAULT_EMAIL_SENDER)
    to = to or htk_setting('HTK_DEFAULT_EMAIL_RECIPIENTS', HTK_DEFAULT_EMAIL_RECIPIENTS)
    if settings.ENV_DEV:
        fail_silently = True
        subject = '[%s-dev] %s' % (htk_setting('HTK_SYMBOLIC_SITE_NAME'), subject,)
    send_mail(subject, message, sender, to, fail_silently=fail_silently)
Esempio n. 25
0
def get_weather(lat, lng):
    base_url = 'https://api.darksky.net/forecast/%(api_key)s/%(lat)s,%(lng)s'
    #base_url = 'https://api.forecast.io/forecast/%(api_key)s/%(lat)s,%(lng)s'
    api_key = htk_setting('HTK_DARKSKY_API_KEY') or htk_setting('HTK_FORECASTIO_API_KEY')
    url = base_url % {
        'api_key' : api_key,
        'lat' : lat,
        'lng' : lng,
    }
    response = requests.get(url)
    if response.status_code == 200:
        weather = json.loads(response.content)
    else:
        weather = None
    return weather
Esempio n. 26
0
 def __init__(self):
     from htk.apps.accounts.cachekeys import AccountActivationReminderEmailCooldown
     template = htk_setting('HTK_ACCOUNT_ACTIVATION_REMINDER_EMAIL_TEMPLATE')
     super(AccountActivationReminderEmails, self).__init__(
         cooldown_class=AccountActivationReminderEmailCooldown,
         template=template
     )
Esempio n. 27
0
def create_customer(card=None, email=None, description=""):
    """Create a Customer

    https://stripe.com/docs/tutorials/charges#saving-credit-card-details-for-later
    https://stripe.com/docs/api/python#create_customer
    """
    live_mode = (settings.ENV_STAGE or settings.ENV_PROD) and htk_setting("HTK_STRIPE_LIVE_MODE")
    _initialize_stripe(live_mode=live_mode)

    params = {"email": email, "description": description}
    if card:
        params["card"] = card
    else:
        pass

    stripe_customer = safe_stripe_call(stripe.Customer.create, **params)
    if stripe_customer:
        StripeCustomerModel = get_stripe_customer_model()
        if StripeCustomerModel:
            customer = StripeCustomerModel.objects.create(stripe_id=stripe_customer.id, live_mode=live_mode)
        else:
            customer = None
    else:
        customer = None
    return customer, stripe_customer
Esempio n. 28
0
 def save(self, domain=None, commit=True):
     domain = domain or htk_setting('HTK_DEFAULT_EMAIL_SENDING_DOMAIN')
     user = super(UserRegistrationForm, self).save(commit=False)
     email = self.email
     # temporarily assign a unique username so that we can create the record and the user can log in
     user.username = email_to_username_hash(email)
     # we'll store the primary email in the User object
     user.email = email
     if not htk_setting('HTK_ACCOUNT_ACTIVATE_UPON_REGISTRATION', False):
         # require user to confirm email account before activating it
         user.is_active = False
     if commit:
         user.save()
         from htk.apps.accounts.utils import associate_user_email
         user_email = associate_user_email(user, email, domain)
     return user
Esempio n. 29
0
 def members_changelist_url(self):
     app_label = htk_setting('HTK_DEFAULT_APP_LABEL')
     members_changelist_url = '%s?organization__id__exact=%s' % (
         reverse('admin:%s_%s_changelist' % (app_label, 'customer',)),
         self.id,
     )
     return members_changelist_url
Esempio n. 30
0
def get_geoip_country():
    geoip_country_db = htk_setting('HTK_LIB_GEOIP_COUNTRY_DB')
    if geoip_country_db:
        gi_country = pygeoip.GeoIP(geoip_country_db)
    else:
        gi_country = None
    return gi_country
Esempio n. 31
0
    def activate(self,
                 email_template=None,
                 email_subject=None,
                 email_sender=None):
        """Activate the User if not already activated
        """
        was_activated = False
        user = self.user
        if not user.is_active:
            user.is_active = True
            user.save()
            was_activated = user.is_active

        if was_activated:
            # trigger notifications for an activated account
            should_send_welcome_email = True

            if htk_setting('HTK_ITERABLE_ENABLED'):
                try:
                    itbl_opts = htk_setting('HTK_ITERABLE_OPTIONS')
                    should_send_welcome_email = not itbl_opts.get(
                        'override_welcome_email', False)

                    from htk.lib.iterable.utils import get_iterable_api_client
                    itbl = get_iterable_api_client()
                    itbl.notify_account_activation(user)
                except:
                    rollbar.report_exc_info()

            if should_send_welcome_email:
                self.send_welcome_email(template=email_template,
                                        subject=email_subject,
                                        sender=email_sender)

            if htk_setting('HTK_SLACK_NOTIFICATIONS_ENABLED'):
                try:
                    from htk.utils.notifications import slack_notify
                    slack_notify('*%s* has activated their account on %s' % (
                        user.email,
                        htk_setting('HTK_SITE_NAME'),
                    ))
                except:
                    rollbar.report_exc_info()

        return was_activated
Esempio n. 32
0
 def get_members(self):
     sort_order = htk_setting('HTK_ORGANIZATION_MEMBERS_SORT_ORDER')
     members = self.members.filter(
         active=True,
         user__is_active=True
     ).order_by(
         *sort_order
     )
     return members
Esempio n. 33
0
class BaseAbstractOrganizationMember(HtkBaseModel):
    user = models.ForeignKey(settings.AUTH_USER_MODEL, related_name='organizations')
    organization = models.ForeignKey(htk_setting('HTK_ORGANIZATION_MODEL'), related_name='members')
    role = models.PositiveIntegerField(default=OrganizationMemberRoles.MEMBER.value, choices=get_organization_member_role_choices())
    active = models.BooleanField(default=True)

    class Meta:
        abstract = True
        verbose_name = 'Organization Member'
Esempio n. 34
0
 def get_members(self):
     sort_order = htk_setting('HTK_ORGANIZATION_TEAM_MEMBERS_SORT_ORDER')
     members = self.members.filter(
         #active=True, # TODO: exclude users that are not active at the organization level
         user__is_active=True
     ).order_by(
         *sort_order
     )
     return members
Esempio n. 35
0
def prelaunch_email(prelaunch_signup):
    template = htk_setting('HTK_PRELAUNCH_EMAIL_TEMPLATE',
                           HTK_PRELAUNCH_EMAIL_TEMPLATE)
    subject = htk_setting('HTK_PRELAUNCH_EMAIL_SUBJECT',
                          HTK_PRELAUNCH_EMAIL_SUBJECT)
    bcc = htk_setting('HTK_PRELAUNCH_EMAIL_BCC', HTK_PRELAUNCH_EMAIL_BCC)

    context = {
        'prelaunch_signup': prelaunch_signup,
        'site_name': htk_setting('HTK_SITE_NAME')
    }
    send_email(template=template,
               subject=subject,
               to=[
                   prelaunch_signup.email,
               ],
               bcc=bcc,
               context=context)
Esempio n. 36
0
def should_display_dismissible_alert(alert_name, alert_template, user, context, *args, **kwargs):
    result = False
    display_predicates = htk_setting('HTK_NOTIFICATIONS_DISMISSIBLE_ALERT_DISPLAY_PREDICATES')
    display_predicate_method = display_predicates.get(alert_name, None)
    if display_predicate_method:
        display_predicate = resolve_method_dynamically(display_predicate_method)
        if display_predicate:
            result = display_predicate(alert_name, alert_template, user, context, *args, **kwargs)
    return result
Esempio n. 37
0
def get_alert_key(alert_name):
    alert_key = None
    alert_key_generators = htk_setting('HTK_NOTIFICATIONS_DISMISSIBLE_ALERT_KEY_GENERATORS')
    generator_method = alert_key_generators.get(alert_name, None)
    if generator_method:
        generator = resolve_method_dynamically(generator_method)
        if generator:
            alert_key = generator(alert_name)
    return alert_key
Esempio n. 38
0
def is_prelaunch_exception_url(path):
    is_excepted = False
    prelaunch_exception_urls = htk_setting('HTK_PRELAUNCH_EXCEPTION_URLS',
                                           HTK_PRELAUNCH_EXCEPTION_URLS)
    for url in prelaunch_exception_urls:
        if re.match(url, path):
            is_excepted = True
            break
    return is_excepted
Esempio n. 39
0
def simple_email(subject='',
                 message='',
                 sender=None,
                 to=None,
                 fail_silently=False):
    """Sends a simple email
    """
    sender = sender or htk_setting('HTK_DEFAULT_EMAIL_SENDER',
                                   HTK_DEFAULT_EMAIL_SENDER)
    to = to or htk_setting('HTK_DEFAULT_EMAIL_RECIPIENTS',
                           HTK_DEFAULT_EMAIL_RECIPIENTS)
    if settings.ENV_DEV:
        fail_silently = True
        subject = '[%s-dev] %s' % (
            htk_setting('HTK_SYMBOLIC_SITE_NAME'),
            subject,
        )
    send_mail(subject, message, sender, to, fail_silently=fail_silently)
Esempio n. 40
0
    def __init__(self, client_id=None, client_secret=None):
        if client_id is None:
            client_id = htk_setting('HTK_ZUORA_CLIENT_ID')
        if client_secret is None:
            client_secret = htk_setting('HTK_ZUORA_CLIENT_SECRET')

        self.client_id = client_id
        self.client_secret = client_secret

        self.access_token = None
        self.access_token_expires_at = None

        zuora_country = htk_setting('HTK_ZUORA_COUNTRY')
        zuora_api_mode = 'prod' if htk_setting('HTK_ZUORA_PROD') else 'sandbox'
        self.api_base_url = HTK_ZUORA_API_BASE_URLS[zuora_country][
            zuora_api_mode]

        self.authenticate()
Esempio n. 41
0
 def _process_registration(self, domain, email_template, email_subject, email_sender, commit):
     domain = domain or htk_setting('HTK_DEFAULT_EMAIL_SENDING_DOMAIN')
     user = super(UserRegistrationForm, self).save(commit=False)
     # temporarily assign a unique username so that we can create the record and the user can log in
     if htk_setting('HTK_ACCOUNTS_REGISTER_SET_PRETTY_USERNAME_FROM_EMAIL', False):
         user.username = email_to_username_pretty_unique(email)
     else:
         user.username = email_to_username_hash(email)
     # we'll store the primary email in the User object
     user.email = email
     if not htk_setting('HTK_ACCOUNT_ACTIVATE_UPON_REGISTRATION', False):
         # require user to confirm email account before activating it
         user.is_active = False
     if commit:
         user.save()
         from htk.apps.accounts.utils import associate_user_email
         user_email = associate_user_email(user, email, domain=domain, email_template=email_template, email_subject=email_subject, email_sender=email_sender)
     return user
Esempio n. 42
0
def log_event(event, request=None, log_level='info', message=None):
    """Log the Stripe event `event`
    """
    live_mode = event.get('livemode', False)
    should_log = live_mode or htk_setting('HTK_STRIPE_LOG_TEST_MODE_EVENTS')
    if should_log:
        logger_type = htk_setting('HTK_STRIPE_EVENT_LOGGER')
        if logger_type == 'rollbar':
            _log_event_rollbar(event,
                               request=None,
                               log_level='info',
                               message=None)
        else:
            # unrecognized Stripe event logger
            pass
    else:
        # do nothing
        pass
Esempio n. 43
0
def process_user_email_association(sender, instance, created, **kwargs):
    """signal handler for UserEmail post-save
    """
    user_email = instance
    if user_email.is_confirmed:
        if htk_setting('HTK_INVITATIONS_LIFECYCLE_SIGNALS_ENABLED'):
            from htk.apps.invitations.services import InvitationsService
            invitations_service = InvitationsService()
            invitations_service.process_user_email_confirmation(user_email)
Esempio n. 44
0
    def send_activation_reminder_email(self,
                                       template=None,
                                       subject=None,
                                       sender=None):
        """Sends an account activation reminder email

        Piggybacks off of `self.send_activation_email`
        """
        if template is None:
            template = htk_setting(
                'HTK_ACCOUNT_ACTIVATION_REMINDER_EMAIL_TEMPLATE')
        if subject is None:
            subject = 'Reminder to activate your account on %s' % htk_setting(
                'HTK_SITE_NAME')
        self.send_activation_email(resend=True,
                                   template=template,
                                   subject=subject,
                                   sender=sender)
Esempio n. 45
0
def get_view_context(request):
    view_context_generator = htk_setting(
        'HTK_PRELAUNCH_VIEW_CONTEXT_GENERATOR', '')
    method = resolve_method_dynamically(view_context_generator)
    if method:
        context = method(request)
    else:
        context = {}
    return context
Esempio n. 46
0
def is_prelaunch_mode():
    is_prelaunch = htk_setting('HTK_PRELAUNCH_MODE', HTK_PRELAUNCH_MODE)
    if settings.TEST:
        from htk.test_scaffold.models import TestScaffold
        scaffold = TestScaffold()
        fake_prelaunch_mode = scaffold.get_fake_prelaunch_mode()
        if fake_prelaunch_mode is not None:
            is_prelaunch = fake_prelaunch_mode
    return is_prelaunch
Esempio n. 47
0
 def get_full_url(self, base_uri=None):
     if base_uri is None:
         domain = htk_setting('HTK_DEFAULT_DOMAIN')
         base_uri = 'http://%s' % domain
     cpq_url = self.get_url()
     full_url = '%s%s' % (
         base_uri,
         cpq_url,
     )
     return full_url
Esempio n. 48
0
    def send_activation_email(self,
                              domain=None,
                              resend=False,
                              template=None,
                              subject=None,
                              sender=None):
        """Sends an activation email
        """
        domain = domain or htk_setting('HTK_DEFAULT_EMAIL_SENDING_DOMAIN')
        self._reset_activation_key(resend=resend)

        try:
            should_send_activation_email = True

            if htk_setting('HTK_ITERABLE_ENABLED'):
                from htk.lib.iterable.utils import get_iterable_api_client
                from htk.lib.iterable.utils import get_campaign_id

                itbl_campaign_id = get_campaign_id(
                    'triggered.account.sign_up_confirm_email')

                if itbl_campaign_id:
                    should_send_activation_email = False

                    data = {
                        'activation_uri':
                        self.get_activation_uri(domain=domain),
                    }

                    itbl = get_iterable_api_client()
                    itbl.send_triggered_email(self.email,
                                              itbl_campaign_id,
                                              data=data)

            if should_send_activation_email:
                activation_email(self,
                                 domain=domain,
                                 template=template,
                                 subject=subject,
                                 sender=sender)
        except:
            request = get_current_request()
            rollbar.report_exc_info(request=request)
Esempio n. 49
0
def slack_notify(message):
    """Send a Slack notification message
    """
    from htk.lib.slack.utils import webhook_call as slack_webhook_call
    try:
        channel = htk_setting('HTK_SLACK_NOTIFICATIONS_CHANNEL')
        slack_webhook_call(text=message, channel=channel)
    except:
        request = get_current_request()
        rollbar.report_exc_info(request=request)
Esempio n. 50
0
 def create_invoice_for_payment(self, stripe_customer, line_items):
     """Creates an invoice for this Quote with successful payment by `stripe_customer` for `line_items`
     """
     InvoiceModel = resolve_model_dynamically(
         htk_setting('HTK_CPQ_INVOICE_MODEL'))
     invoice = InvoiceModel.objects.create(date=utcnow(),
                                           customer=self.customer,
                                           paid=True,
                                           quote=self)
     invoice.record_payment(stripe_customer, line_items)
Esempio n. 51
0
def get_site_name(request=None):
    """Returns the current site name
    """
    site = get_current_site(request=request)
    site_name = site.name if site else None

    if not site_name:
        site_name = htk_setting('HTK_SITE_NAME')

    return site_name
Esempio n. 52
0
 def has_company_email_domain(self):
     """Determines whether this User has email with company domain
     """
     company_email_domains = htk_setting('HTK_COMPANY_EMAIL_DOMAINS')
     company_email_domains_re = '|'.join(
         [domain.replace(r'\.', r'\.') for domain in company_email_domains])
     value = bool(
         re.match(r'^[A-Za-z0-9\.\+_-]+@(%s)' % company_email_domains_re,
                  self.user.email))
     return value
Esempio n. 53
0
 def organizations(self):
     from htk.utils.general import resolve_model_dynamically
     Organization = resolve_model_dynamically(
         htk_setting('HTK_ORGANIZATION_MODEL'))
     organizations = Organization.objects.filter(
         members__user=self.user, members__active=True).order_by(
             'name',
             'handle',
         )
     return organizations
Esempio n. 54
0
 def members_changelist_url(self):
     app_label = htk_setting('HTK_DEFAULT_APP_LABEL')
     members_changelist_url = '%s?organization__id__exact=%s' % (
         reverse('admin:%s_%s_changelist' % (
             app_label,
             'customer',
         )),
         self.id,
     )
     return members_changelist_url
Esempio n. 55
0
def get_event_type(event):
    """Get event type from Alexa skill webhook `event`
    """
    event_type_resolver_module_str = htk_setting(
        'HTK_ALEXA_SKILL_EVENT_TYPE_RESOLVER')
    from htk.utils.general import resolve_method_dynamically
    event_type_resolver = resolve_method_dynamically(
        event_type_resolver_module_str)
    event_type = event_type_resolver(event)
    return event_type
Esempio n. 56
0
def reset_password(request,
                   data=None,
                   redirect_url_name='account_password_reset_success',
                   template='account/reset_password.html',
                   renderer=_r):
    """
    View that checks the hash in a password reset link and presents a
    form for entering a new password.
    Based off of django.contrib.auth.views.password_reset_confirm
    Need to customize error display
    """
    if data is None:
        data = wrap_data(request)

    uidb36 = request.GET.get('u', None)
    token = request.GET.get('t', None)
    token_generator = default_token_generator
    success = False
    response = None
    if uidb36 and token:
        UserModel = get_user_model()
        try:
            uid_int = base36_to_int(uidb36)
            user = UserModel.objects.get(id=uid_int)
        except (ValueError, UserModel.DoesNotExist):
            user = None

        if user is not None and token_generator.check_token(user, token):
            validlink = True
            if request.method == 'POST':
                form = UpdatePasswordForm(user, request.POST)
                if form.is_valid():
                    user = form.save()
                    if htk_setting(
                            'HTK_ACCOUNTS_CHANGE_PASSWORD_UPDATE_SESSION_AUTH_HASH'
                    ):
                        from django.contrib.auth import update_session_auth_hash
                        update_session_auth_hash(request, user)
                    success = True
            else:
                form = UpdatePasswordForm(None)
            if 'input_attrs' in data:
                set_input_attrs(form, attrs=data['input_attrs'])
        else:
            validlink = False
            form = None
        data['form'] = form
        data['validlink'] = validlink
    else:
        data['validlink'] = False
    if success:
        response = redirect(reverse(redirect_url_name))
    else:
        response = renderer(request, template, data=data)
    return response
Esempio n. 57
0
def webhook_call(webhook_url=None,
                 channel=None,
                 username=None,
                 text='',
                 attachments=None,
                 icon_emoji=None,
                 unfurl_links=True,
                 unfurl_media=True,
                 error_response_handlers=None):
    """Performs a webhook call to Slack

    https://api.slack.com/incoming-webhooks
    https://api.slack.com/docs/message-formatting

    `channel` override must be a public channel
    """
    if webhook_url is None:
        webhook_url = htk_setting('HTK_SLACK_WEBHOOK_URL')

    payload = {
        'text': text,
        'unfurl_links': unfurl_links,
        'unfurl_media': unfurl_media,
    }
    if channel:
        payload['channel'] = channel
    if username:
        payload['username'] = username
    if icon_emoji:
        payload['icon_emoji'] = icon_emoji
    if attachments:
        payload['attachments'] = attachments

    response = requests.post(webhook_url, json=payload)
    if response.status_code == 200:
        # success case, do nothing
        pass
    elif response.status_code <= 399:
        # 200-300, do nothing
        pass
    else:
        if handle_webhook_error_response(response, error_response_handlers):
            # successfully handled the webhook error
            pass
        else:
            extra_data = {
                'webhook_url': webhook_url,
                'payload': payload,
            }
            rollbar.report_message('Slack webhook call error: [%s] %s' % (
                response.status_code,
                response.content,
            ),
                                   extra_data=extra_data)
    return response
Esempio n. 58
0
def check_email(strategy, details, user=None, *args, **kwargs):
    """Ask the user to enter the email if we don't have one yet

    The pipeline process was cut prior to this custom pipeline function, and will resume to this same function after completing
    """
    response = None
    if user is None:
        strategy.request.session['backend'] = kwargs.get(
            'current_partial').backend
        social_email = details.get('email')
        collected_email = strategy.request.session.get(
            SOCIAL_REGISTRATION_SETTING_EMAIL)
        if social_email:
            # email available from social auth
            user = get_user_by_email(social_email)
            if user and user.is_active:
                # a user is already associated with this email
                # TODO: there is an error with linking accounts...
                strategy.request.session[
                    SOCIAL_REGISTRATION_SETTING_EMAIL] = social_email
                if user.has_usable_password():
                    # user should log into the existing account with a password
                    url_name = htk_setting(
                        'HTK_ACCOUNTS_REGISTER_SOCIAL_LOGIN_URL_NAME')
                else:
                    # no password was set, so user must log in with another social auth account
                    url_name = htk_setting(
                        'HTK_ACCOUNTS_REGISTER_SOCIAL_ALREADY_LINKED_URL_NAME')
                response = redirect(url_name)
        elif collected_email:
            # email provided by user
            details['email'] = collected_email
            response = {'details': details}
        else:
            # no email provided from social auth
            strategy.request.session[
                SOCIAL_REGISTRATION_SETTING_MISSING_EMAIL] = True
            url_name = htk_setting(
                'HTK_ACCOUNTS_REGISTER_SOCIAL_EMAIL_URL_NAME')
            response = redirect(url_name)

    return response
Esempio n. 59
0
def get_zestimate(zpid, zwsid=None):
    """Get the Zestimate for `zpid`
    `zpid` Zillow property id

    http://www.zillow.com/howto/api/GetZestimate.htm
    """
    if zwsid is None:
        zwsid = htk_setting('HTK_ZILLOW_ZWSID')

    zestimate = Zestimate(zpid, zwsid)
    return zestimate
Esempio n. 60
0
def get_num_server_api_keys():
    """Returns the number of Google server API keys configured
    """
    key = htk_setting('HTK_GOOGLE_SERVER_API_KEY')
    if type(key) == str:
        num = 1
    elif hasattr(key, '__iter__'):
        num = len(key)
    else:
        num = 0
    return num