Exemplo n.º 1
0
    def test_existing_user_cancel_subscription(self, mocked_date):
        user = self._make_user(
            email='*****@*****.**',
            groups=[
                Group.by_name('enabled'),
                Group.by_name('trial'),
                Group.by_name('monthly'),
            ])
        mocked_date.today.return_value = date(2013, 12, 30)

        view = IPNView(testing.DummyRequest())
        view.provider = 'clickbank'
        view.params = AttrDict({
            'email': '*****@*****.**',
            'trans_type': 'RFND',
            'trans_id': 123,
            'product_id': 1,
        })
        resp = view.ipn()
        self.assertEqual(resp, 'Done.')
        self.assertEqual(user.enabled, False)
        self.assertEqual(user.valid_to, date(2013, 12, 30))

        self.assertEqual(len(user.audit_log_entries), 1)
        self.assertEqual(
            user.audit_log_entries[0].event_type.name, u'UserDisabled')
        self.assertEqual(
            user.audit_log_entries[0].comment,
            u'Disabled by clickbank, transaction id: 123, type: RFND, note: '
            u'removed from groups: enabled, trial, monthly',
        )
Exemplo n.º 2
0
    def test_existing_trial_user_new_subscription_payment(
        self, mocked_date, user=None
    ):
        if not user:
            user = self._make_user(
                email='*****@*****.**',
                groups=[Group.by_name('enabled'), Group.by_name('trial')],
            )

        mocked_date.today.return_value = date(2013, 12, 30)
        view = IPNView(testing.DummyRequest())
        view.provider = 'jvzoo'
        view.params = AttrDict({
            'email': '*****@*****.**',
            'fullname': u'Föo Bar',
            'trans_type': 'BILL',
            'trans_id': 123,
            'product_id': 1,
        })

        resp = view.ipn()
        self.assertEqual(resp, 'Done.')
        self.assertEqual(user.enabled, True)
        self.assertEqual(user.trial, False)
        self.assertEqual(user.valid_to, date(2014, 1, 30))
        self.assertEqual(user.last_payment, date(2013, 12, 30))

        self.assertEqual(len(user.audit_log_entries), 1)
        self.assertEqual(
            user.audit_log_entries[0].event_type.name, u'UserEnabled')
        self.assertEqual(
            user.audit_log_entries[0].comment,
            u'Enabled by jvzoo, transaction id: 123, type: BILL, note: '
            u'regular until 2014-01-30',
        )
Exemplo n.º 3
0
    def __init__(self, request):
        self.request = request
        self.schema = SQLAlchemySchemaNode(
            User,
            includes=self.fields,
            overrides={
                'properties': {'includes': ['key', 'value']},
                'email': {'validator': deferred_user_email_validator},
                'billing_email': {
                    'validator': deferred_user_billing_email_validator}
            }
        )

        # we don't like the way ColanderAlchemy renders SA Relationships so
        # we manually inject a suitable SchemaNode for groups
        choices = [(group.id, group.name) for group in Group.get_all()]
        enabled = Group.by_name('enabled')
        choices.remove((enabled.id, enabled.name))
        if not request.user.admin:
            admins = Group.by_name('admins')
            choices.remove((admins.id, admins.name))
        self.schema.add(
            node=colander.SchemaNode(
                colander.Set(),
                name='groups',
                missing=[],
                widget=deform.widget.CheckboxChoiceWidget(values=choices),
                validator=deferred_groups_validator,
            ),
        )
Exemplo n.º 4
0
 def __call__(self):
     warnings = []
     if not Group.by_name('admins'):
         warnings.append('Group "admins" missing.')
     if not Group.by_name('enabled'):
         warnings.append('Group "enabled" missing.')
     if not Group.by_name('trial'):
         warnings.append('Group "trial" missing.')
     return warnings
Exemplo n.º 5
0
    def test_exclude(self):
        add_groups()
        add_users()
        mailing = _make_mailing(
            name='foo',
            groups=[Group.by_name('enabled')],
            exclude_groups=[Group.by_name('admins'),
                            Group.by_name('staff')],
        )
        self.request.context = mailing

        self.assertItemsEqual(
            self.view.recipients,
            [User.by_email('*****@*****.**')],
        )
Exemplo n.º 6
0
 def test_existing_regular_user_new_subscription_payment(self):
     """Test for the "ValueError: list.remove(x): x not in list" bug."""
     user = self._make_user(
         email='*****@*****.**',
         groups=[Group.by_name('enabled')],
     )
     self.test_existing_trial_user_new_subscription_payment(user=user)
Exemplo n.º 7
0
def add_users():
    """Init the '*****@*****.**' and '*****@*****.**' user accounts."""
    with transaction.manager:
        admins = Group.by_name('admins')
        staff = Group.by_name('staff')
        enabled = Group.by_name('enabled')
        trial = Group.by_name('trial')

        # Create the admin user account
        admin = User(
            email=u'*****@*****.**',
            password=SECRET_ENC,
            fullname=u'Ädmin',
            properties=[
                UserProperty(key=u'bimt', value=u'on'),
            ],
        )
        admin.groups.append(admins)
        admin.groups.append(enabled)
        Session.add(admin)

        # Create the staff member account
        staff_member = User(
            email=u'*****@*****.**',
            password=SECRET_ENC,
            fullname=u'Stäff Member',
            properties=[
                UserProperty(key=u'bimt', value=u'on'),
            ],
        )
        staff_member.groups.append(enabled)
        staff_member.groups.append(staff)
        Session.add(staff_member)

        # Create the normal user account
        one = User(
            email=u'*****@*****.**',
            billing_email=u'*****@*****.**',
            password=SECRET_ENC,
            fullname=u'Öne Bar',
            properties=[
                UserProperty(key=u'bimt', value=u'on'),
            ],
        )
        one.groups.append(enabled)
        one.groups.append(trial)
        Session.add(one)
Exemplo n.º 8
0
    def test_non_admin_and_non_admins(self):
        from pyramid_bimt.views.user import deferred_groups_validator
        self.request.user.admin = False
        cstruct = [
            str(Group.by_name('staff').id),
        ]

        validator = deferred_groups_validator(None, {'request': self.request})
        self.assertFalse(validator(None, cstruct))
Exemplo n.º 9
0
def add_demo_portlet():
    """Create a dummy portlet."""
    with transaction.manager:
        admins = Group.by_name('admins')
        enabled = Group.by_name('enabled')

        portlet = Portlet(
            name='dummy',
            groups=[
                admins,
            ],
            exclude_groups=[
                enabled,
            ],
            position=PortletPositions.below_sidebar.name,
            weight=-127,
            html=u'You are admin.',
        )
        Session.add(portlet)
Exemplo n.º 10
0
    def __call__(self):
        warnings = []
        user = User.by_id(1)

        if not user:
            warnings.append('User "admin" should have id of "1".')
        if user and user.enabled:
            warnings.append('User "admin" should be disabled in production.')
        if user and Group.by_name('admins') not in user.groups:
            warnings.append('User "admin" should be in "admins" group.')
        return warnings
Exemplo n.º 11
0
    def test_context_name_allowed_for_name(self):
        from pyramid_bimt.views.group import deferred_group_name_validator

        schema = SQLAlchemySchemaNode(Group)
        self.request.context = Group.by_name('enabled')
        self.request.POST['name'] = 'enabled'

        validator = deferred_group_name_validator(None,
                                                  {'request': self.request})

        self.assertFalse(validator(schema.get('name'), 'enabled'))
Exemplo n.º 12
0
def add_demo_mailing():
    """Create a dummy mailing."""
    with transaction.manager:
        trial = Group.by_name('trial')
        admins = Group.by_name('admins')

        mailing = Mailing(
            name='welcome_email',
            groups=[
                trial,
            ],
            exclude_groups=[
                admins,
            ],
            trigger=MailingTriggers.after_created.name,
            days=1,
            subject=u'Über Welcome!',
            body=u'Welcome to this über amazing BIMT app!',
        )
        Session.add(mailing)
Exemplo n.º 13
0
    def test_not_in_unsubscribed(self, get_current_request):
        get_current_request.return_value = self.request
        add_routes_user(self.config)
        self.request.user = User.by_email('*****@*****.**')
        self.request.context = _make_mailing(
            id=123,
            name='excluded',
            groups=[Group.by_name('admins'),
                    Group.by_name('enabled')],
            exclude_groups=[],
            body=u'Body',
            subject=u'Subject')

        mailer = get_mailer(self.request)

        self.request.context.send(self.request.user)

        self.assertEqual(len(mailer.outbox), 1)
        self.assertEqual(mailer.outbox[0].subject, u'Subject')
        self.assertNotIn('Unsubscribe from our Newsletter',
                         mailer.outbox[0].html)  # noqa
Exemplo n.º 14
0
    def test_context_product_id_allowed_for_product_id(self):
        from pyramid_bimt.views.group import deferred_group_product_id_validator  # noqa

        schema = SQLAlchemySchemaNode(Group)
        self.request.context = Group.by_name('enabled')
        self.request.context.product_id = '123'
        self.request.POST['product_id'] = '123'

        validator = deferred_group_product_id_validator(
            None, {'request': self.request})

        self.assertFalse(validator(schema.get('product_id'), '123'))
Exemplo n.º 15
0
    def ipn_bill_transaction(self, user, group):
        """Handle IPN bill transaction.

        :param    user:  Selected user
        :type     user:  pyramid_bimt.models.user.User
        :param    group: Group that user belongs to
        :type     group: pyramid_bimt.models.Groups.Group
        """
        validity = timedelta(days=group.validity)
        valid_to = date.today() + validity

        if group.addon:
            user.set_property('addon_{}_valid_to'.format(group.product_id),
                              valid_to)
            user.set_property('addon_{}_last_payment'.format(group.product_id),
                              date.today())
            action = u'Addon "{}" enabled'.format(group.name)
        else:
            user.valid_to = valid_to
            user.last_payment = date.today()
            user.enable()
            action = u'Enabled'

            if Group.by_name('trial') in user.groups:
                user.groups.remove(Group.by_name('trial'))

        if group not in user.groups:  # pragma: no branch
            user.groups.append(group)

        comment = COMMENT.format(
            action,
            self.provider,
            self.params.trans_id,
            self.params.trans_type,
            'regular until {}'.format(valid_to),
        )
        logger.info(comment)
        self.request.registry.notify(UserEnabled(self.request, user, comment))
Exemplo n.º 16
0
    def test_loginas_view_submit_success_as_user(self):
        from pyramid_bimt.models import User
        from pyramid_bimt.models import Group
        from pyramid_bimt.views.auth import LoginAs

        Session.add(
            User(email='*****@*****.**', groups=[
                Group.by_name('enabled'),
            ]))

        context = User.by_email('*****@*****.**')
        context.groups.append(Group.by_name('impersonators'))
        request = testing.DummyRequest(
            layout_manager=mock.Mock(),
            session=mock.Mock(),
        )
        form_values = {'email': '*****@*****.**'}
        request.user = context
        view = LoginAs(request)
        resp = view.login_as_success(form_values)
        self.assertEqual(resp.location, 'http://example.com')
        request.session.flash.assert_called_once_with(
            u'You have successfully logged in as user "*****@*****.**".')
Exemplo n.º 17
0
    def test_existing_user_refund_after_upgrade(self, mocked_date):
        user = self._make_user(
            email='*****@*****.**',
            groups=[
                Group.by_name('enabled'),
                Group.by_name('trial'),
                Group.by_name('monthly'),
            ])
        user.set_property('upgrade_completed', True)

        view = IPNView(testing.DummyRequest())
        view.provider = 'clickbank'
        view.params = AttrDict({
            'email': '*****@*****.**',
            'trans_type': 'RFND',
            'trans_id': 123,
            'product_id': 1,
        })
        resp = view.ipn()
        self.assertEqual(resp, 'Done.')
        self.assertEqual(user.enabled, True)
        self.assertIn(Group.by_name('monthly'), user.groups)

        self.assertEqual(len(user.audit_log_entries), 0)
Exemplo n.º 18
0
    def test_non_admin_and_admins(self):
        from pyramid_bimt.views.user import deferred_groups_validator
        self.request.user.admin = False
        cstruct = [
            str(Group.by_name('admins').id),
        ]

        validator = deferred_groups_validator(None, {'request': self.request})
        with self.assertRaises(colander.Invalid) as cm:
            validator(None, cstruct)

        self.assertEqual(
            cm.exception.msg,
            'Only admins can add users to "admins" group.',
        )
Exemplo n.º 19
0
    def test_new_user_no_trial(self, mocked_date):
        Group.by_name('monthly').trial_validity = None
        mocked_date.today.return_value = date(2013, 12, 30)

        view = IPNView(testing.DummyRequest())
        view.provider = 'clickbank'
        view.params = AttrDict({
            'email': '*****@*****.**',
            'fullname': u'Föo Bar',
            'trans_type': 'SALE',
            'trans_id': 123,
            'product_id': 1,
            'affiliate': '*****@*****.**',
        })
        resp = view.ipn()
        self.assertEqual(resp, 'Done.')

        user = User.by_email('*****@*****.**')
        self.assertEqual(user.enabled, True)
        self.assertEqual(user.trial, False)
        self.assertEqual(user.affiliate, '*****@*****.**')
        self.assertEqual(user.valid_to, date(2014, 1, 30))
        self.assertEqual(user.last_payment, date(2013, 12, 30))

        self.assertEqual(len(user.audit_log_entries), 2)

        self.assertEqual(
            user.audit_log_entries[0].event_type.name, u'UserCreated')
        self.assertEqual(
            user.audit_log_entries[0].comment,
            u'Created by clickbank, transaction id: 123, type: SALE, note: ',
        )

        self.assertEqual(
            user.audit_log_entries[1].event_type.name, u'UserEnabled')
        self.assertEqual(
            user.audit_log_entries[1].comment,
            u'Enabled by clickbank, transaction id: 123, type: SALE, note: '
            u'regular until 2014-01-30',
        )
Exemplo n.º 20
0
    def save_success(self, appstruct):
        user = self.request.context

        user.email = appstruct.get('email')
        user.fullname = appstruct.get('fullname')
        user.affiliate = appstruct.get('affiliate')
        user.billing_email = appstruct.get('billing_email')
        user.valid_to = appstruct.get('valid_to')
        user.last_payment = appstruct.get('last_payment')

        if appstruct.get('password'):
            user.password = encrypt(appstruct['password'])

        groups = [Group.by_id(group_id) for group_id in appstruct['groups']]
        enabled = Group.by_name('enabled')
        if enabled in user.groups:
            groups.append(enabled)
        user.groups = groups

        # remove properties that are not present in appstruct
        for prop in copy.copy(user.properties):
            if prop.key not in [p['key'] for p in appstruct['properties']]:
                user.properties.remove(prop)

        # update/create properties present in appstruct
        for prop in appstruct['properties']:
            if user.has_property(prop['key']):
                user.set_property(key=prop['key'], value=prop.get('value'))
            else:
                user.properties.append(
                    UserProperty(key=prop['key'], value=prop.get('value')))

        self.request.session.flash(
            u'User "{}" modified.'.format(user.email))
        return HTTPFound(
            location=self.request.route_path(
                'user_view', user_id=user.id))
Exemplo n.º 21
0
 def validator(node, cstruct):
     id_ = str(Group.by_name('admins').id)
     if (not request.user.admin) and (id_ in cstruct):
         raise colander.Invalid(
             node, u'Only admins can add users to "admins" group.')
Exemplo n.º 22
0
 def validator(node, cstruct):
     if Group.by_name(cstruct):
         raise colander.Invalid(
             node, u'Group with name "{}" already exists.'.format(cstruct))