def test_moderate_reject_url(self):
        '''
        There is a url to moderate a message
        '''
        message = Message.objects.create(
            content='Content 1',
            author_name='Felipe',
            author_email="*****@*****.**",
            subject='Fiera es una perra feroz',
            public=False,
            writeitinstance=self.writeitinstance,
            persons=[self.person1],
            )
        message.recently_confirmated()
        url = reverse('reject_message', subdomain=message.writeitinstance.slug, kwargs={'pk': message.pk})
        self.client.login(username=self.writeitinstance.owner.username, password='******')
        response = self.client.post(url)

        message_again = Message.objects.get(id=message.id)
        self.assertTrue(message_again.moderated)
        self.assertFalse(message.public)

        '''Redirecting'''
        allmessages_url = reverse('messages_per_writeitinstance', subdomain=self.writeitinstance.slug)
        self.assertRedirects(response, allmessages_url)
Exemplo n.º 2
0
    def test_url_update(self):
        url = reverse('mailit-template-update', subdomain=self.writeitinstance.slug)

        self.assertTrue(url)

        c = self.client
        c.login(username="******", password="******")

        data = {
            'subject_template': 'Hello there you have a new mail this is subject',
            'content_template': 'hello there this is the content and you got this message',
            'content_html_template': '<tag>hello there this is the content and you got this message</tag>',
        }

        response = c.post(url, data=data)
        url = reverse('writeitinstance_template_update', subdomain=self.writeitinstance.slug)
        self.assertRedirects(response, url)

        self.assertEquals(
            self.writeitinstance.mailit_template.subject_template,
            data['subject_template'],
            )
        self.assertEquals(
            self.writeitinstance.mailit_template.content_template,
            data['content_template'],
            )
Exemplo n.º 3
0
    def send_moderation_mail(self):
        plaintext = get_template('nuntium/mails/moderation_mail.txt')
        htmly = get_template('nuntium/mails/moderation_mail.html')
        current_site = Site.objects.get_current()
        current_domain = 'http://'+current_site.domain
        url_rejected = reverse('moderation_rejected', kwargs={
            'slug': self.moderation.key
            })

        url_accept = reverse('moderation_accept', kwargs={
            'slug': self.moderation.key
            })

        d = Context({
            'message': self,
            'url_rejected':url_rejected,
            'url_accept':url_accept
             })

        text_content = plaintext.render(d)
        html_content = htmly.render(d)
        from_email = self.writeitinstance.slug+"@"+settings.DEFAULT_FROM_DOMAIN


        msg = EmailMultiAlternatives(_('Moderation required for\
         a message in WriteIt'),
            text_content,#content
            from_email,#From
            [self.writeitinstance.owner.email]#To
            )
        msg.attach_alternative(html_content, "text/html")
        msg.send()
Exemplo n.º 4
0
 def test_wildcard_reverse(self):
     # Falls through to settings.ROOT_URLCONF
     subdomain = 'wildcard'
     self.assertEqual(reverse('home', subdomain),
         'http://%s.%s/' % (subdomain, self.DOMAIN))
     self.assertEqual(reverse('view', subdomain),
         'http://%s.%s/view/' % (subdomain, self.DOMAIN))
 def test_there_is_an_endpoint(self):
     """There is an endpoint to which posting updates an answer"""
     reverse(
         "update_answer",
         subdomain=self.message.writeitinstance.slug,
         kwargs={"message_pk": self.answer.message.pk, "pk": self.answer.pk},
     )
Exemplo n.º 6
0
 def get_absolute_url(self):
     if self.series:
         return reverse(
             'articles:article',
             args=[self.series.slug, self.slug], subdomain='articles')
     return reverse(
         'articles:article', args=[self.slug], subdomain='articles')
    def test_post_to_create_an_instance(self):
        c = self.client
        c.login(username=self.user.username, password='******')
        url = reverse('create_writeit_instance')

        response = c.post(url, data=self.data)
        instance = WriteItInstance.objects.get(slug='test-instance-slug', owner=self.user)
        self.assertRedirects(response, reverse('welcome', subdomain=instance.slug))
        self.assertTrue(instance.persons.all())
Exemplo n.º 8
0
def list_all(request):
    """Catch all view that combines results from units and challenges."""
    if not request.user.is_authenticated():
        return HttpResponse(status=401)

    group_id = request.GET.get('group', None)
    if group_id is None:
        return HttpResponse(status=400)

    group = get_object_or_404(Group, pk=int(group_id))

    login_base = reverse('app_login', subdomain='accounts',
            scheme=request.scheme)

    units = []
    # TODO: Actually make this list group dependant.
    for unit in LearningUnit.objects.all():
        activity = unit.get_next_activity_for_user(request.user)
        token = create_token(
            request.user.pk,
            group.pk,
            activity.app.pk).decode('utf-8')
        units.append({
            'id': unit.pk,
            'label': unit.label,
            'login': "******" % (login_base, token),
            'token': token})

    challenges = []
    # TODO: Actually make this list group dependant.
    for challenge in Challenge.objects.all():
        app = get_app_by_url(challenge.url)
        if app is not None:
            token = create_token(
                request.user.pk,
                group.pk,
                app.pk).decode('utf-8')
            login_url = "%s?token=%s" % (login_base, token)
        else:
            token = None
            login_url = None

        challenges.append({
            'id': challenge.pk,
            'label': challenge.label,
            'url': route_links_in_text(request, challenge.url, group),
            'login': login_url,
            'token': token,
            'details': "%s/?group=%s" % (
                reverse("collections_challenge_detail", args=(challenge.pk,),
                        subdomain="api",scheme=request.scheme),
                group_id),
            'body': route_links_in_text(request, challenge.body, group),
            })

    return JsonResponse({'items': {'units': units, 'challenges': challenges}})
Exemplo n.º 9
0
 def test_there_is_a_url_for_posting_new_webhooks(self):
     '''There is a url where we can post information for a new webhook'''
     url = reverse('writeitinstance_create_webhooks', subdomain=self.writeitinstance.slug)
     self.client.login(username=self.writeitinstance.owner.username, password='******')
     data = {'url': 'http://new.answers.will.be.posted/here'}
     response = self.client.post(url, data=data)
     url_listing_webhooks = reverse('writeitinstance_webhooks', subdomain=self.writeitinstance.slug)
     self.assertRedirects(response, url_listing_webhooks)
     webhook = self.writeitinstance.answer_webhooks.first()
     self.assertEquals(webhook.url, data['url'])
 def test_there_is_an_endpoint(self):
     '''There is an endpoint to which posting updates an answer'''
     reverse(
         'update_answer',
         subdomain=self.message.writeitinstance.slug,
         kwargs={
             'message_pk': self.answer.message.pk,
             'pk': self.answer.pk
             },
         )
Exemplo n.º 11
0
    def test_post_to_create_an_instance(self):
        your_instances_url = reverse('your-instances')
        c = Client()
        c.login(username=self.user.username, password='******')
        url = reverse('create_writeit_instance')
        self.assertTrue(url)

        response = c.post(url, data=self.data)
        self.assertRedirects(response, your_instances_url)
        instance = WriteItInstance.objects.get(Q(name='instance'), Q(owner=self.user))
        self.assertTrue(instance.persons.all())
Exemplo n.º 12
0
    def test_it_redirects_to_your_instances(self):
        '''When get to create an instance it redirects to your instances'''
        url = reverse('create_writeit_instance')
        c = Client()

        response = c.get(url)
        c.login(username=self.user.username, password='******')

        response = c.get(url)
        your_instances_url = reverse('your-instances')
        self.assertRedirects(response, your_instances_url)
Exemplo n.º 13
0
 def test_insights_about_pulling_popit_even_if_everything_goes_ok(self):
     '''Return some insights even if everything goes ok'''
     self.client.login(username="******", password="******")
     url = reverse('relate-writeit-popit', subdomain=self.writeitinstance.slug)
     data = self.data
     response = self.client.post(url, data=data)
     expected_follow_url = reverse('relate-writeit-popit', subdomain=self.writeitinstance.slug)
     self.assertRedirects(response, expected_follow_url)
     response = self.client.get(expected_follow_url)
     messages = list(response.context['messages'])
     self.assertTrue(messages)
     self.assertEquals(messages[0].message, _("We are now getting the people from popit"))
    def test_go_straight_to_draft_given_person_id(self):
        url = reverse('write_message_step',
            subdomain=self.writeitinstance.slug,
            kwargs={'step': 'who'})
        url2 = reverse('write_message_step',
            subdomain=self.writeitinstance.slug,
            kwargs={'step': 'draft'})

        response = self.client.get(url, {'person_id': self.person1.popit_id})
        self.assertRedirects(response, url2)
        response = self.client.get(url2)
        self.assertEquals(response.context['message']['persons'][0].id, self.person1.id)
    def test_posting_to_that_url_rejects_the_message(self):
        """When posting to reject a message it marks it private"""
        url = reverse("reject_message", subdomain=self.writeitinstance.slug, kwargs={"pk": self.message.pk})

        c = self.client
        c.login(username=self.writeitinstance.owner.username, password="******")
        response = c.post(url)
        """It should redirect to the see all messages url"""
        allmessages_url = reverse("messages_per_writeitinstance", subdomain=self.writeitinstance.slug)
        self.assertRedirects(response, allmessages_url)
        message = Message.objects.get(pk=self.message.pk)
        self.assertFalse(message.public)
        self.assertTrue(message.moderated)
Exemplo n.º 16
0
    def test_post_to_url(self):
        '''When I post to the URL then it deletes the writeitinstance'''
        url = reverse('delete_an_instance', subdomain=self.writeitinstance.slug)
        request = self.factory.post(url)
        request.user = self.writeitinstance.owner
        response = WriteItDeleteView.as_view()(request)
        # Now it should be deleted
        self.assertFalse(WriteItInstance.objects.filter(id=self.writeitinstance.id))

        your_instances_url = reverse('your-instances')
        self.assertTrue(response)
        self.assertEquals(response.status_code, 302)
        self.assertEquals(response.url, your_instances_url)
    def test_posting_to_that_url_rejects_the_message(self):
        '''When posting to reject a message it marks it private'''
        url = reverse('reject_message', subdomain=self.writeitinstance.slug, kwargs={'pk': self.message.pk})

        c = self.client
        c.login(username=self.writeitinstance.owner.username, password='******')
        response = c.post(url)
        '''It should redirect to the see all messages url'''
        allmessages_url = reverse('messages_per_writeitinstance', subdomain=self.writeitinstance.slug)
        self.assertRedirects(response, allmessages_url)
        message = Message.objects.get(pk=self.message.pk)
        self.assertFalse(message.public)
        self.assertTrue(message.moderated)
    def test_post_to_the_url(self):
        '''It should reject the get to that url'''
        self.client.login(username="******", password="******")
        url = reverse('relate-writeit-popit', subdomain=self.writeitinstance.slug)
        response = self.client.post(url, data=self.data)
        self.assertEquals(response.status_code, 302)
        basic_update_url = reverse('relate-writeit-popit', subdomain=self.writeitinstance.slug)

        self.assertRedirects(response, basic_update_url)

        records = WriteitInstancePopitInstanceRecord.objects.filter(writeitinstance=self.writeitinstance)
        self.assertEquals(records.count(), 1)
        # this means that it has persons related to it
        self.assertTrue(self.writeitinstance.persons.all())
Exemplo n.º 19
0
 def test_turning_moderation_on(self):
     url = reverse('writeitinstance_moderation_update', subdomain=self.writeitinstance.slug)
     modified_data = {'moderation_needed_in_all_messages': 'on'}
     self.client.login(username=self.owner.username, password='******')
     self.client.post(url, data=modified_data, follow=True)
     writeitinstance = WriteItInstance.objects.get(id=self.writeitinstance.id)
     self.assertTrue(writeitinstance.config.moderation_needed_in_all_messages)
Exemplo n.º 20
0
 def test_rate_limit_cannot_be_negative(self):
     url = reverse('writeitinstance_ratelimiter_update', subdomain=self.writeitinstance.slug)
     modified_data = {'rate_limiter': -1}
     self.client.login(username=self.owner.username, password='******')
     response = self.client.post(url, data=modified_data, follow=True)
     self.assertTrue(response.context['form'].errors)
     self.assertTrue(response.context['form'].errors['rate_limiter'])
Exemplo n.º 21
0
    def test_access_the_search_url(self):
        url = reverse('search_messages')
        url += '/'
        response = self.client.get(url)

        self.assertEquals(response.status_code, 200)
        self.assertIsInstance(response.context['form'], MessageSearchForm)
Exemplo n.º 22
0
 def test_change_rate_limit(self):
     url = reverse('writeitinstance_ratelimiter_update', subdomain=self.writeitinstance.slug)
     modified_data = {'rate_limiter': 10}
     self.client.login(username=self.owner.username, password='******')
     self.client.post(url, data=modified_data, follow=True)
     writeitinstance = WriteItInstance.objects.get(id=self.writeitinstance.id)
     self.assertEquals(writeitinstance.config.rate_limiter, 10)
Exemplo n.º 23
0
def url(context, view, subdomain=UNSET, *args, **kwargs):
    """
    Resolves a URL in a template, using subdomain-based URL resolution.

    If no subdomain is provided and a ``request`` is in the template context
    when rendering, the URL will be resolved relative to the current request's
    subdomain. If no ``request`` is provided, the URL will be resolved relative
    to current domain with the ``settings.ROOT_URLCONF``.

    Usage::

        {% load subdomainurls %}
        {% url 'view-name' subdomain='subdomain' %}

    .. note:: This tag uses the variable URL syntax introduced in Django
       1.3 as ``{% load url from future %}`` and was made the standard in Django
       1.5. If you are upgrading a legacy application from one of the previous
       template tag formats, make sure to quote your constant string URL names
       to avoid :exc:`~django.core.urlresolver.NoReverseMatch` errors during
       template rendering.

    """
    if subdomain is UNSET:
        request = context.get("request")
        if request is not None:
            subdomain = getattr(request, "subdomain", None)
        else:
            subdomain = None
    elif subdomain is "":
        subdomain = None

    return reverse(view, subdomain=subdomain, args=args, kwargs=kwargs)
Exemplo n.º 24
0
 def test_max_recipients_cannot_rise_more_than_settings(self):
     url = reverse('writeitinstance_recipients_settings_update', subdomain=self.writeitinstance.slug)
     modified_data = {'maximum_recipients': 11}
     self.client.login(username=self.owner.username, password='******')
     response = self.client.post(url, data=modified_data, follow=True)
     self.assertTrue(response.context['form'].errors)
     self.assertTrue(response.context['form'].errors['maximum_recipients'])
Exemplo n.º 25
0
    def test_create_an_instance_get_not_logged(self):
        '''Create an instance get'''

        url = reverse('create_writeit_instance')
        c = self.client
        response = c.get(url)
        self.assertRedirectToLogin(response)
Exemplo n.º 26
0
    def test_updating_templates_views(self):
        self.writeitinstance.owner.set_password("feroz")
        self.writeitinstance.owner.save()
        c = self.client
        c.login(username=self.writeitinstance.owner.get_username(), password='******')

        url = reverse('writeitinstance_template_update', subdomain=self.writeitinstance.slug)

        response = c.get(url)
        self.assertEquals(response.status_code, 200)
        self.assertTemplateUsed(response, 'base_manager.html')
        self.assertTemplateUsed(response, 'nuntium/profiles/templates.html')
        self.assertIsInstance(response.context['new_answer_template_form'], NewAnswerNotificationTemplateForm)
        self.assertIsInstance(response.context['mailit_template_form'], MailitTemplateForm)
        confirmation_template_form = response.context['confirmation_template_form']
        self.assertIsInstance(confirmation_template_form, ConfirmationTemplateForm)
        mailit_template_form = response.context['mailit_template_form']
        self.assertEquals(mailit_template_form.instance, self.writeitinstance.mailit_template)
        form = response.context['new_answer_template_form']
        self.assertEquals(form.instance, self.writeitinstance.new_answer_notification_template)
        self.assertEquals(confirmation_template_form.writeitinstance, self.writeitinstance)
        self.assertEquals(confirmation_template_form.instance, self.writeitinstance.confirmationtemplate)
        non_user = self.client_class()

        response2 = non_user.get(url)
        self.assertRedirectToLogin(response2, next_url=url)

        # Benito does not own the instance
        User.objects.create_user(username="******", email="*****@*****.**", password="******")

        fiera_client = self.client
        fiera_client.login(username="******", password="******")

        response = fiera_client.get(url)
        self.assertEquals(response.status_code, 404)
Exemplo n.º 27
0
    def test_per_instance_api_docs(self):
        url = reverse('writeitinstance_api_docs', subdomain=self.writeitinstance.slug)
        request = self.factory.get(url)
        request.user = self.writeitinstance.owner

        response = WriteItInstanceApiDocsView.as_view()(request, pk=self.writeitinstance.pk)
        self.assertContains(response, 'api/v1/message/?format=json&username=admin&api_key=')
Exemplo n.º 28
0
 def test_turning_api_autoconfirm_off(self):
     url = reverse('writeitinstance_api_autoconfirm_update', subdomain=self.writeitinstance.slug)
     modified_data = {}
     self.client.login(username=self.owner.username, password='******')
     self.client.post(url, data=modified_data, follow=True)
     writeitinstance = WriteItInstance.objects.get(id=self.writeitinstance.id)
     self.assertFalse(writeitinstance.config.autoconfirm_api_messages)
Exemplo n.º 29
0
 def test_turning_web_based_on(self):
     url = reverse('writeitinstance_webbased_update', subdomain=self.writeitinstance.slug)
     modified_data = {'allow_messages_using_form': 'on'}
     self.client.login(username=self.owner.username, password='******')
     self.client.post(url, data=modified_data, follow=True)
     writeitinstance = WriteItInstance.objects.get(id=self.writeitinstance.id)
     self.assertTrue(writeitinstance.config.allow_messages_using_form)
Exemplo n.º 30
0
 def test_set_max_recipients_to_1(self):
     url = reverse('writeitinstance_recipients_settings_update', subdomain=self.writeitinstance.slug)
     modified_data = {'maximum_recipients': 1}
     self.client.login(username=self.owner.username, password='******')
     self.client.post(url, data=modified_data, follow=True)
     writeitinstance = WriteItInstance.objects.get(id=self.writeitinstance.id)
     self.assertEquals(writeitinstance.config.maximum_recipients, 1)
Exemplo n.º 31
0
 def test_get_the_url(self):
     url = reverse('message_threads', subdomain=self.writeitinstance.slug)
     response = self.client.get(url)
     self.assertEquals(response.status_code, 200)
     public_messages = Message.public_objects.filter(
         writeitinstance=self.writeitinstance)
     self.assertEquals(len(response.context['message_list']),
                       public_messages.count())
Exemplo n.º 32
0
 def test_rate_limit_cannot_be_negative(self):
     url = reverse('writeitinstance_ratelimiter_update',
                   subdomain=self.writeitinstance.slug)
     modified_data = {'rate_limiter': -1}
     self.client.login(username=self.owner.username, password='******')
     response = self.client.post(url, data=modified_data, follow=True)
     self.assertTrue(response.context['form'].errors)
     self.assertTrue(response.context['form'].errors['rate_limiter'])
Exemplo n.º 33
0
 def test_get_answers_per_messages_is_not_reachable_by_non_user(self):
     """
     When a user is not logged in he cannot see the answers per message
     """
     url = reverse('message_detail_private', subdomain=self.writeitinstance.slug, kwargs={'pk': self.message.pk})
     c = self.client
     response = c.get(url)
     self.assertRedirectToLogin(response, next_url=url)
Exemplo n.º 34
0
 def test_max_recipients_cannot_rise_more_than_settings(self):
     url = reverse('writeitinstance_maxrecipients_update',
                   subdomain=self.writeitinstance.slug)
     modified_data = {'maximum_recipients': 11}
     self.client.login(username=self.owner.username, password='******')
     response = self.client.post(url, data=modified_data, follow=True)
     self.assertTrue(response.context['form'].errors)
     self.assertTrue(response.context['form'].errors['maximum_recipients'])
    def test_has_an_url(self):
        url = reverse('messages_per_person',
                      subdomain=self.writeitinstance.slug,
                      kwargs={
                          'pk': self.pedro.id,
                      })

        self.assertTrue(url)
Exemplo n.º 36
0
 def test_confirmation_get_absolute_url(self):
     confirmation = Confirmation.objects.create(message=self.message)
     expected_url = reverse(
         'confirm',
         subdomain=self.message.writeitinstance.slug,
         kwargs={'slug': confirmation.key},
         )
     self.assertEquals(expected_url, confirmation.get_absolute_url())
Exemplo n.º 37
0
    def test_get_absolute_url(self):
        writeitinstance1 = WriteItInstance.objects.get(id=1)
        expected_url = reverse(
            'instance_detail',
            subdomain=writeitinstance1.slug,
        )

        self.assertEquals(expected_url, writeitinstance1.get_absolute_url())
Exemplo n.º 38
0
    def test_it_cannot_be_accessed_by_a_non_user(self):
        '''A non user cannot reject a message'''

        url = reverse('reject_message', subdomain=self.writeitinstance.slug, kwargs={'pk': self.message.pk})

        c = self.client
        response = c.get(url)
        self.assertRedirectToLogin(response, next_url=url)
Exemplo n.º 39
0
    def test_it_does_not_confirm_twice(self):
        confirmation = Confirmation.objects.create(message=self.message)
        url = reverse(
            'confirm',
            subdomain=self.message.writeitinstance.slug,
            kwargs={'slug': confirmation.key},
            )
        response1 = self.client.get(url)
        message_thread = reverse(
            'thread_read', subdomain=self.message.writeitinstance.slug,
            kwargs={
                'slug': self.message.slug
            })
        response2 = self.client.get(url)

        self.assertEquals(response1.status_code, 302)
        self.assertRedirects(response2, message_thread)
Exemplo n.º 40
0
 def test_the_messages_url_is_not_reachable_by_non_user(self):
     """
     The messages url is not reachable by someone who is not logged in
     """
     url = reverse('messages_per_writeitinstance', subdomain=self.writeitinstance.slug)
     c = self.client
     response = c.get(url)
     self.assertRedirectToLogin(response, next_url=url)
 def test_person_id_param(self):
     url = reverse('messages_per_person_id',
                   subdomain=self.writeitinstance.slug,
                   kwargs={
                       'person_id': self.pedro.popit_id,
                   })
     response = self.client.get(url)
     self.assertEquals(response.context['person'], self.pedro)
Exemplo n.º 42
0
    def test_if_moderation_needed_moderation_column_displayed(self):
        self.writeitinstance.config.moderation_needed_in_all_messages = True
        self.writeitinstance.config.save()

        url = reverse('messages_per_writeitinstance', subdomain=self.writeitinstance.slug)
        self.client.login(username=self.writeitinstance.owner.username, password='******')
        response = self.client.get(url)
        self.assertContains(response, 'Moderated')
Exemplo n.º 43
0
 def test_get_url(self):
     '''Get the url for creating a new instance (it doesn't redrect anywhere)'''
     url = reverse('create_writeit_instance')
     request = self.factory.get(url)
     request.user = self.user
     response = WriteItInstanceCreateView.as_view()(request)
     # print response.render()
     self.assertEquals(response.status_code, 200)
Exemplo n.º 44
0
 def test_post_to_create_an_answer(self):
     '''
     When posting for the creation of an answer
     '''
     previous_count = Answer.objects.filter(message=self.message).count()
     data = {
         'person': self.message.people.all()[0].pk,
         'content': "hello this is an answer",
         }
     url = reverse('create_answer', subdomain=self.writeitinstance.slug, kwargs={'pk': self.message.pk})
     c = self.client
     c.login(username=self.writeitinstance.owner.username, password='******')
     response = c.post(url, data=data)
     detail_message_url = reverse('message_detail_private', subdomain=self.message.writeitinstance.slug, kwargs={'pk': self.message.pk})
     self.assertRedirects(response, detail_message_url)
     new_count = Answer.objects.filter(message=self.message).count()
     self.assertEquals(new_count, previous_count + 1)
Exemplo n.º 45
0
 def get_absolute_url(self):
     return reverse(
         'thread_read',
         subdomain=self.writeitinstance.slug,
         kwargs={
             'slug': self.slug,
         },
     )
Exemplo n.º 46
0
    def test_post_to_the_url(self):
        '''It should reject the get to that url'''
        self.client.login(username="******", password="******")
        url = reverse('relate-writeit-popit',
                      subdomain=self.writeitinstance.slug)
        response = self.client.post(url, data=self.data)
        self.assertEquals(response.status_code, 302)
        basic_update_url = reverse('relate-writeit-popit',
                                   subdomain=self.writeitinstance.slug)

        self.assertRedirects(response, basic_update_url)

        records = WriteitInstancePopitInstanceRecord.objects.filter(
            writeitinstance=self.writeitinstance)
        self.assertEquals(records.count(), 1)
        # this means that it has persons related to it
        self.assertTrue(self.writeitinstance.persons.all())
Exemplo n.º 47
0
    def test_I_can_access_the_docs(self):
        url = reverse('user_section_documentation')
        self.assertTrue(url)
        c = self.client
        c.login(username=self.writeitinstance.owner.username, password='******')

        response = c.get(url)
        self.assertTemplateUsed(response, "nuntium/profiles/docs.html")
Exemplo n.º 48
0
def send_confirmation_email(sender, instance, created, **kwargs):
    confirmation = instance
    if created:
        confirmation_url = reverse(
            'confirm',
            subdomain=confirmation.message.writeitinstance.slug,
            kwargs={'slug': confirmation.key},
        )
        message_full_url = confirmation.message.get_absolute_url()
        plaintext = confirmation.message.writeitinstance.confirmationtemplate.get_content_template(
        )
        htmly = confirmation.message.writeitinstance.confirmationtemplate.content_html
        subject = confirmation.message.writeitinstance.confirmationtemplate.get_subject_template(
        )
        subject = subject.rstrip()

        context = {
            'author_name': confirmation.message.author_name,
            'site_name': confirmation.message.writeitinstance.name,
            'subject': confirmation.message.subject,
            'content': confirmation.message.content,
            'recipients':
            u', '.join([x.name for x in confirmation.message.people]),
            'confirmation_url': confirmation_url,
            'message_url': message_full_url,
        }

        text_content = template_with_wrap(plaintext, context)
        subject = subject.format(**context)
        html_content = htmly.format(**escape_dictionary_values(context))

        if settings.SEND_ALL_EMAILS_FROM_DEFAULT_FROM_EMAIL:
            from_email = settings.DEFAULT_FROM_EMAIL
        else:
            from_domain = confirmation.message.writeitinstance.config.custom_from_domain\
                or settings.DEFAULT_FROM_DOMAIN
            from_email = "%s@%s" % (
                confirmation.message.writeitinstance.slug,
                from_domain,
            )
        connection = confirmation.message.writeitinstance.config.get_mail_connection(
        )

        msg = EmailMultiAlternatives(
            subject,
            text_content,
            from_email,
            [confirmation.message.author_email],
            connection=connection,
        )

        if html_content:
            msg.attach_alternative(html_content, "text/html")

        try:
            msg.send()
        except:
            pass
Exemplo n.º 49
0
 def test_turning_api_autoconfirm_off(self):
     url = reverse('writeitinstance_api_autoconfirm_update',
                   subdomain=self.writeitinstance.slug)
     modified_data = {}
     self.client.login(username=self.owner.username, password='******')
     self.client.post(url, data=modified_data, follow=True)
     writeitinstance = WriteItInstance.objects.get(
         id=self.writeitinstance.id)
     self.assertFalse(writeitinstance.config.autoconfirm_api_messages)
Exemplo n.º 50
0
 def test_post_updated_answer(self):
     '''Posting updated answer'''
     url = reverse(
         'update_answer',
         subdomain=self.message.writeitinstance.slug,
         kwargs={
             'message_pk': self.answer.message.pk,
             'pk': self.answer.pk
             },
         )
     c = self.client
     c.login(username=self.writeitinstance.owner.username, password='******')
     data = {'content': "this is the new content"}
     response = c.post(url, data=data)
     detail_message_url = reverse('message_detail_private', subdomain=self.message.writeitinstance.slug, kwargs={'pk': self.message.pk})
     self.assertRedirects(response, detail_message_url)
     answer = Answer.objects.get(id=self.answer.id)
     self.assertTrue(answer.content, data['content'])
Exemplo n.º 51
0
    def test_if_theres_a_single_contact_skip_the_first_step(self):
        '''If theres a single contact skip the first step and select the single person'''
        url = reverse('write_message_step',
            subdomain=self.writeitinstance.slug,
            kwargs={'step': 'who'})
        # Deleting Marcel
        self.writeitinstance.persons.get(id=2).delete()
        # ok so I've deleted Marcel from the list of people that is in this instance
        # so when I get this response I'm expecting to take me directly to
        # the second step .
        response = self.client.get(url)
        url2 = reverse('write_message_step',
            subdomain=self.writeitinstance.slug,
            kwargs={'step': 'draft'})

        self.assertRedirects(response, url2)
        response2 = self.client.get(url2)
        self.assertEquals(response2.status_code, 200)
Exemplo n.º 52
0
 def test_turning_answer_notification_off(self):
     url = reverse('writeitinstance_answernotification_update',
                   subdomain=self.writeitinstance.slug)
     modified_data = {}
     self.client.login(username=self.owner.username, password='******')
     self.client.post(url, data=modified_data, follow=True)
     writeitinstance = WriteItInstance.objects.get(
         id=self.writeitinstance.id)
     self.assertFalse(writeitinstance.config.notify_owner_when_new_answer)
Exemplo n.º 53
0
 def test_get_the_url_brings_the_instance_and_renders_the_template(self):
     '''When getting the url brings some stats and renders the specific template'''
     url = reverse('stats', subdomain=self.writeitinstance.slug)
     self.client.login(username=self.writeitinstance.owner,
                       password="******")
     response = self.client.get(url)
     self.assertEquals(response.status_code, 200)
     self.assertIn('writeitinstance', response.context)
     self.assertTemplateUsed(response, 'nuntium/profiles/stats.html')
Exemplo n.º 54
0
 def test_list_instances(self):
     activate('en')
     instance1 = WriteItInstance.objects.get(id=1)
     url = reverse("home")
     response = self.client.get(url)
     self.assertEquals(response.status_code, 200)
     self.assertTrue(response.context['writeitinstances'])
     self.assertEquals(response.context['writeitinstances'].count(), 2)
     self.assertEquals(response.context['writeitinstances'][0], instance1)
Exemplo n.º 55
0
 def test_change_rate_limit(self):
     url = reverse('writeitinstance_ratelimiter_update',
                   subdomain=self.writeitinstance.slug)
     modified_data = {'rate_limiter': 10}
     self.client.login(username=self.owner.username, password='******')
     self.client.post(url, data=modified_data, follow=True)
     writeitinstance = WriteItInstance.objects.get(
         id=self.writeitinstance.id)
     self.assertEquals(writeitinstance.config.rate_limiter, 10)
Exemplo n.º 56
0
 def test_turning_web_based_on(self):
     url = reverse('writeitinstance_webbased_update',
                   subdomain=self.writeitinstance.slug)
     modified_data = {'allow_messages_using_form': 'on'}
     self.client.login(username=self.owner.username, password='******')
     self.client.post(url, data=modified_data, follow=True)
     writeitinstance = WriteItInstance.objects.get(
         id=self.writeitinstance.id)
     self.assertTrue(writeitinstance.config.allow_messages_using_form)
Exemplo n.º 57
0
 def test_set_max_recipients_to_1(self):
     url = reverse('writeitinstance_recipients_settings_update',
                   subdomain=self.writeitinstance.slug)
     modified_data = {'maximum_recipients': 1}
     self.client.login(username=self.owner.username, password='******')
     self.client.post(url, data=modified_data, follow=True)
     writeitinstance = WriteItInstance.objects.get(
         id=self.writeitinstance.id)
     self.assertEquals(writeitinstance.config.maximum_recipients, 1)
Exemplo n.º 58
0
    def test_the_url_exists_and_is_reachable_when_logged(self):
        c = self.client
        c.login(username='******', password='******')
        url = reverse('account')
        response = c.get(url)

        self.assertEquals(response.status_code, 200)
        self.assertTemplateUsed(response, "nuntium/profiles/your-profile.html")
        self.assertTemplateUsed(response, "base_manager.html")
Exemplo n.º 59
0
def register(request):
    form = UserForm()
    if request.method == 'POST':
        form = UserForm(request.POST)
        if form.is_valid():
            school = form.save()
            return redirect(reverse('school', subdomain=school.username))

    return render(request, 'register.html', {'form': form})
 def test_get_messages_404(self):
     '''Gets a 404 if the slug of an instance does not exist'''
     url = reverse(
         'all-messages-from-the-same-author-as',
         subdomain='non-existing',
         kwargs={
             'message_slug': self.message.slug,  # This slug does not exists
         })
     self.assertEquals(self.client.get(url).status_code, 404)