Example #1
0
 def test_deferred_default_user_email(self):
     from voteit.core.schemas.common import deferred_default_user_email as fut
     from voteit.core.views.api import APIView
     root = bootstrap_and_fixture(self.config)
     admin = root.users['admin']
     admin.set_field_value('email', '*****@*****.**')
     self.config.testing_securitypolicy(userid='admin')
     kw = {'api': APIView(root, self.request)}
     self.assertEqual(fut(None, kw), '*****@*****.**')
     self.config.testing_securitypolicy(userid='404')
     kw = {'api': APIView(root, self.request)}
     self.assertEqual(fut(None, kw), '')
Example #2
0
 def test_deferred_default_user_fullname(self):
     from voteit.core.schemas.common import deferred_default_user_fullname as fut
     from voteit.core.views.api import APIView
     root = bootstrap_and_fixture(self.config)
     admin = root.users['admin']
     admin.set_field_value('first_name', 'Jane')
     admin.set_field_value('last_name', 'Doe')
     self.config.testing_securitypolicy(userid='admin')
     kw = {'api': APIView(root, self.request)}
     self.assertEqual(fut(None, kw), 'Jane Doe')
     self.config.testing_securitypolicy(userid='404')
     kw = {'api': APIView(root, self.request)}
     self.assertEqual(fut(None, kw), '')
 def _mk_one(self,
             context=testing.DummyModel(),
             default_deferred=_dummy_default_deferred):
     from voteit.core.views.api import APIView
     request = testing.DummyRequest()
     api = APIView(context, request)
     return self._cut(context, api, default_deferred)
Example #4
0
 def test_render_poll_state_info(self):
     from voteit.core.models.poll import Poll
     from voteit.core.views.api import APIView
     from voteit.core.testing_helpers import register_workflows
     register_workflows(self.config)
     self.config.include('pyramid_chameleon')
     self.config.registry.settings[
         'default_timezone_name'] = "Europe/Stockholm"
     self.config.include('voteit.core.models.date_time_util')
     self.config.scan('voteit.core.views.components.main')
     #root = active_poll_fixture(self.config)
     #poll = root['meeting']['ai']['poll']
     poll = Poll()
     from voteit.core.models.date_time_util import utcnow
     poll.set_field_value('start_time', utcnow())
     poll.set_field_value('end_time', utcnow())
     request = testing.DummyRequest()
     #obj = self._cut(poll, request)
     api = APIView(poll, request)
     res = render_view_action(poll,
                              request,
                              'main',
                              'poll_state_info',
                              api=api)
     #obj.get_poll_state_info(poll)
     self.assertIn('The poll starts', res)
 def test_func(self):
     from voteit.core.views.api import APIView
     root = _fixture(self.config)
     context = root['users']['admin']
     request = testing.DummyRequest()
     api = APIView(context, request)
     res = self._fut(context, request, None, api=api)
     self.assertIn("The story of an administrator", res)
 def test_get_vote_schema(self):
     #Enable workflows
     self.config.include('pyramid_zcml')
     self.config.load_zcml('voteit.core:configure.zcml')
     obj = self._make_obj()
     request = testing.DummyRequest()
     from voteit.core.views.api import APIView
     api = APIView(self.poll, request)
     self.assertTrue(obj.get_vote_schema(request, api), colander.Schema)
 def test_func_context_outside_meeting(self):
     from voteit.core.views.api import APIView
     root = _fixture(self.config)
     self._extra_fixtures(root)
     context = root['users']['admin']
     request = testing.DummyRequest()
     api = APIView(context, request)
     res = self._fut(context, request, None, api=api)
     #All things should be in view now
     self.assertIn("Prop p1", res)
     self.assertIn("Disc d2", res)
 def test_func_context_meeting(self):
     from voteit.core.views.api import APIView
     root = _fixture(self.config)
     self._extra_fixtures(root)
     context = root['users']['admin']
     request = testing.DummyRequest()
     #Means that api.meeting will be set, and limit results to meeting context
     api = APIView(root['m'], request)
     res = self._fut(context, request, None, api=api)
     #m2 things shouldn't be in meeting now
     self.assertIn("Prop p1", res)
     self.assertIn("Disc d1", res)
     self.assertNotIn("Prop p2", res)
     self.assertNotIn("Disc d2", res)
 def test_integration(self):
     from voteit.core.models.user import User
     from voteit.core.views.api import APIView
     self.config.include('pyramid_chameleon')
     self.config.scan('voteit.core.views.components.user_info')
     context = User()
     request = testing.DummyRequest()
     api = APIView(context, request)
     self.assertIsInstance(
         render_view_action(context,
                            request,
                            'user_info',
                            'basic_profile',
                            api=api), unicode)
 def test_integration(self):
     from voteit.core.models.user import User
     from voteit.core.views.api import APIView
     self.config.scan('voteit.core.views.components.user_info')
     root = _fixture(self.config)
     root['u'] = context = User()
     request = testing.DummyRequest()
     api = APIView(context, request)
     self.assertIsInstance(
         render_view_action(context,
                            request,
                            'user_info',
                            'latest_meeting_entries',
                            api=api), unicode)
Example #11
0
    def test_render_poll_result(self):
        #note: This shouldn't test the template since that's covered by each plugin
        request = testing.DummyRequest()
        poll = self._cut()
        _marker = object()

        from voteit.core.views.api import APIView
        api = APIView(poll, request)

        class _MockPollPlugin(PollPlugin):
            def render_result(self, request, api, complete=True):
                return _marker

        self.config.registry.registerAdapter(_MockPollPlugin, (IPoll,), IPollPlugin, 'mock_poll_plugin')
        poll.set_field_value('poll_plugin', 'mock_poll_plugin')
        self.assertEqual(poll.render_poll_result(request, api), _marker)
    def test_render_result(self):
        self.config.include('pyramid_chameleon')
        self.config.scan('voteit.core.models.proposal')
        self.config.scan('voteit.core.views.components.main')
        self.config.scan('voteit.core.views.components.moderator_actions')
        self.config.scan('voteit.core.views.components.creators_info')
        self.config.scan('voteit.core.views.components.proposals')
        self.config.scan('voteit.core.views.components.user_tags')
        self.config.scan('voteit.core.views.components.metadata_listing')
        self.config.registry.settings[
            'default_timezone_name'] = "Europe/Stockholm"
        self.config.include('voteit.core.models.date_time_util')

        self._add_votes()
        self._close_poll()
        plugin = self.poll.get_poll_plugin()
        request = self.request
        ai = find_interface(self.poll, IAgendaItem)
        request.context = ai
        from voteit.core.views.api import APIView
        api = APIView(ai, request)
        self.assertTrue('p2uid' in plugin.render_result(request, api))
Example #13
0
def _api(context=None, request=None):
    from voteit.core.views.api import APIView
    context = context and context or testing.DummyResource()
    request = request and request or testing.DummyRequest()
    return APIView(context, request)
Example #14
0
 def __init__(self, exception, request):
     self.exception = exception
     self.context = request.context
     self.request = request
     self.api = APIView(request.context, request)
Example #15
0
class ExceptionView(object):
    """ Exception view, for error messages.
        Note that context might not be related to what caused the error.
    """
    def __init__(self, exception, request):
        self.exception = exception
        self.context = request.context
        self.request = request
        self.api = APIView(request.context, request)

    @view_config(context=HTTPForbidden, permission=NO_PERMISSION_REQUIRED)
    def forbidden_view(self):
        """ I.e. 403. If it is a xhr request return Forbidden else 
            find first context where user has view permission
            if they're logged in, otherwise redirect to login form.
        """
        if self.request.is_xhr:
            return HTTPForbidden(self.exception.detail)
        self.api.flash_messages.add(self.exception.detail,
                                    type='error',
                                    close_button=False)
        # is user logged in
        if self.api.userid:
            obj = self.context
            while obj.__parent__:
                if self.api.context_has_permission(security.VIEW, obj):
                    url = resource_url(obj, self.request)
                    return HTTPFound(location=url)
                obj = obj.__parent__
            return HTTPFound(location=self.request.application_url)
        #Redirect to login
        return HTTPFound(location="%s/login?came_from=%s" %
                         (self.request.application_url, self.request.url))

    @view_config(context=HTTPNotFound, permission=NO_PERMISSION_REQUIRED)
    def not_found_view(self):
        """ I.e. 404. If it is a xhr request return NotFound else
            find first context where user has view permission 
        """
        err_msg = _(
            u"404_error_msg",
            default=
            u"Can't find anything at '${path}'. Maybe it has been removed?",
            mapping={'path': self.exception.detail})
        if self.request.is_xhr:
            return HTTPNotFound(err_msg)
        self.api.flash_messages.add(err_msg, type='error', close_button=False)
        return HTTPFound(location=_find_good_redirect_url(
            self.context, self.request, self.api))

    @view_config(context=SMTPError, permission=NO_PERMISSION_REQUIRED)
    def smtp_error_view(self):
        """ SMTP connection error caused during transaction commits.
            Note that the SMTP action is performed after the request has completed.
            In other words, things may be committed to database even though send failed.
        """
        if self.request.is_xhr:
            raise self.exception
        exc_txt = unicode(self.exception)
        err_msg = _(u"smtp_error_msg",
                    default=u"There was an error while sending mail. "
                    u"Error was: ${exc_txt}",
                    mapping={'exc_txt': exc_txt})
        self.api.flash_messages.add(err_msg, type='error')
        logger.critical("SMTP exception: %s" % exc_txt)
        return HTTPFound(location=_find_good_redirect_url(
            self.context, self.request, self.api))
Example #16
0
 def __init__(self, exception, request):
     self.exception = exception
     self.context = request.context
     self.request = request
     self.api = APIView(request.context, request)
Example #17
0
class ExceptionView(object):
    """ Exception view, for error messages.
        Note that context might not be related to what caused the error.
    """

    def __init__(self, exception, request):
        self.exception = exception
        self.context = request.context
        self.request = request
        self.api = APIView(request.context, request)
    
    @view_config(context=HTTPForbidden, permission=NO_PERMISSION_REQUIRED)
    def forbidden_view(self):
        """ I.e. 403. If it is a xhr request return Forbidden else 
            find first context where user has view permission
            if they're logged in, otherwise redirect to login form.
        """
        if self.request.is_xhr:
            return HTTPForbidden(self.exception.detail)
        self.api.flash_messages.add(self.exception.detail,
                                    type = 'error',
                                    close_button = False)
        # is user logged in
        if self.api.userid:
            obj = self.context
            while obj.__parent__:
                if self.api.context_has_permission(security.VIEW, obj):
                    url = self.request.resource_url(obj)
                    return HTTPFound(location = url)
                obj = obj.__parent__
            return HTTPFound(location = self.request.application_url)
        #Redirect to login
        return HTTPFound(location="%s/login?came_from=%s" %(self.request.application_url, self.request.url))

    @view_config(context = HTTPNotFound, permission = NO_PERMISSION_REQUIRED)
    def not_found_view(self):
        """ I.e. 404. If it is a xhr request return NotFound else
            find first context where user has view permission 
        """
        err_msg = _(u"404_error_msg",
                    default = u"Can't find anything at '${path}'. Maybe it has been removed?",
                    mapping = {'path': self.exception.detail})
        if self.request.is_xhr:
            return HTTPNotFound(err_msg)
        self.api.flash_messages.add(err_msg,
                                    type = 'error',
                                    close_button = False)
        return HTTPFound(location = _find_good_redirect_url(self.context, self.request, self.api))

    @view_config(context = SMTPError, permission = NO_PERMISSION_REQUIRED)
    def smtp_error_view(self):
        """ SMTP connection error caused during transaction commits.
            Note that the SMTP action is performed after the request has completed.
            In other words, things may be committed to database even though send failed.
        """
        if self.request.is_xhr:
            raise self.exception
        exc_txt = unicode(self.exception)
        err_msg = _(u"smtp_error_msg",
                    default = u"There was an error while sending mail. "
                        u"Error was: ${exc_txt}",
                    mapping = {'exc_txt': exc_txt})
        self.api.flash_messages.add(err_msg,
                                    type = 'error')
        logger.critical("SMTP exception: %s" % exc_txt)
        return HTTPFound(location = _find_good_redirect_url(self.context, self.request, self.api))

    @view_config(context = HTTPError, permission = NO_PERMISSION_REQUIRED, renderer = "voteit.core:views/templates/exception.pt")
    def error_view(self):
        """ More chatty http-errors that users might need to understand.
            Will also catch CSRF errors.
        """
        if self.request.is_xhr:
            raise self.exception
        return {'exc': self.exception, 'api': self.api}
Example #18
0
 def __init__(self, request):
     self.api = APIView(request.context, request)
     self.request = request
Example #19
0
 def __init__(self, context, request):
     self.context = context
     self.request = request
     self.response = {}
     self.response['api'] = self.api = APIView(context, request)
     self.api.include_needed(context, request, self)