Beispiel #1
0
def remove_access_group(request, team, group_id):
    try:
        group = AccessGroup.objects.get(team=team, id=group_id)
    except AccessGroup.DoesNotExist:
        return HttpResponseRedirect(reverse('sentry-manage-access-groups', args=[team.slug]))

    if request.method == 'POST':
        form = RemoveAccessGroupForm(request.POST)
    else:
        form = RemoveAccessGroupForm()

    if form.is_valid():
        group.delete()

        messages.add_message(request, messages.SUCCESS,
            _('%s was permanently removed.') % (group.name,))

        return HttpResponseRedirect(reverse('sentry-manage-access-groups', args=[team.slug]))

    context = csrf(request)
    context.update({
        'form': form,
        'group': group,
        'page': 'details',
        'SUBSECTION': 'groups',
    })

    return render_with_team_context(team, 'sentry/teams/groups/remove.html', context, request)
Beispiel #2
0
def login_view(request, message='', username="", password="", template='user/login.html', modal=False):
    modal = request.REQUEST.get("modal", False)
    close = request.REQUEST.get("close", False)
    if modal == "true":
        template = 'user/login_modal.html'

    if not request.user.is_anonymous():
        return HttpResponseRedirect(reverse("home"))

    next = request.REQUEST.get('next', reverse('home'))

    if request.POST:
        username = request.POST['username']
        email_exists = User.objects.filter(email=username)
        if email_exists:
            username = email_exists[0].username

        password = request.POST['password']

        user = authenticate(username=username, password=password)

        if user is not None:
            if user.is_active:
                login(request, user)
                return SuccessfulSignInRedirect(next, modal, request, close=close)

        message = "Error logging you in, are you sure you're using the right credentials?"

    context ={'message' : message, 'next' : next, 'username': username, 'password': password, 'modal': modal, 'close': close }
    return render_to_response(template, context, context_instance = RequestContext(request))
 def test_ajax_url_reverse(self):
     url = reverse("tracking:ajax_charter_events", args=[9999])
     self.assertEqual(url, "/tracking/ajax/charter_events/9999/")
     url = reverse("tracking:ajax_ds_charter_list")
     self.assertEqual(url, "/tracking/ajax/charters/")
     url = reverse("tracking:new_charter_modal")
     self.assertEqual(url, "/tracking/ajax/charter/modal/")
Beispiel #4
0
def access_group_members(request, team, group_id):
    try:
        group = AccessGroup.objects.get(team=team, id=group_id)
    except AccessGroup.DoesNotExist:
        return HttpResponseRedirect(reverse('sentry-manage-access-groups', args=[team.slug]))

    form = NewAccessGroupMemberForm(request.POST or None)
    if form.is_valid():
        user = form.cleaned_data['user']
        group.members.add(user)

        messages.add_message(request, messages.SUCCESS,
            _('%s was added to this access group.') % (user.email,))

        return HttpResponseRedirect(reverse('sentry-access-group-members', args=[team.slug, group.id]))

    context = csrf(request)
    context.update({
        'group': group,
        'form': form,
        'member_list': group.members.all(),
        'group_list': AccessGroup.objects.filter(team=team),
        'page': 'members',
        'SUBSECTION': 'groups',
    })

    return render_with_team_context(team, 'sentry/teams/groups/members.html', context, request)
Beispiel #5
0
 def test_manga_report_view_post(self):
     ReportManga.open.filter(manga=self.manga, created_by=self.user).delete()
     response = self.client.post(
         reverse("manga.report", args=[self.manga.id, self.manga.slug]),
         {"type": ReportMangaType.COPYRIGHT, "comment": "This is a standard copyright violation.", "check": "on"},
     )
     self.assertRedirects(response, reverse("manga.list"))
Beispiel #6
0
def profile_page(request, view_user):
    if not request.user.is_authenticated():
        return HttpResponseRedirect(reverse('forum.views.main_index',))
    else:
        if request.user.username == view_user:
            if request.method == 'POST':
                #print request.FILES
                form_profile = ProfileUpdate(request.POST, request.FILES)
                if form_profile.is_valid():
                    # process data
                    cd = form_profile.cleaned_data
                    user_update = ForumUser.objects.get(user=request.user)
                    
                    success_reply = []
                    
                    if request.FILES:
                        f = request.FILES['avatar_img']
                        
                        destination = open('%s/avatars/%s' % (settings.MEDIA_ROOT, f.name), 'wb+')
                        for chunk in f.chunks():
                            destination.write(chunk)
                        destination.close()
                        
                        user_update.avatar_img = "avatars/%s" % f.name
                        user_update.save()
                        
                        # uploadedImage = cd['avatar_img']
                        # user_update = (request.FILES)
                    
                    if(cd['password1']):
                        user_update.user.set_password(cd['password1'])
                        user_update.user.save()
                        success_reply.append('Password')
                        
                    if(cd['email1'] != user_update.user.email and cd['email1'] != ''):
                        user_update.user.email = cd['email1']
                        user_update.user.save()
                        success_reply.append('Email')
                    
                    return render_to_response('profile_page.html', {'form_profile' : form_profile, 'success_reply': success_reply,
                                'forum_user': user_update, 'site_root': reverse('forum.views.main_index'), },
                                context_instance=RequestContext(request))
            else:
                default_data = {
                    'email1': request.user.email,
                    'email2': request.user.email,
                }
        
                form_profile = ProfileUpdate(default_data)
                try:
                    forum_user = ForumUser.objects.get(user=request.user)
                except:
                    forum_user = ForumUser(user=request.user)
                    forum_user.save()
        
            return render_to_response('profile_page.html', {'form_profile' : form_profile, 'forum_user' : forum_user,
                                'site_root': reverse('forum.views.main_index',),},
                                context_instance=RequestContext(request))
        else:
            return HttpResponseRedirect(reverse('forum.views.main_index',))
 def test_charter_url_reverse(self):
     url = reverse("tracking:charter_add")
     self.assertEqual(url, "/tracking/charter/new/")
     url = reverse("tracking:charter_update", args=[9999])
     self.assertEqual(url, "/tracking/charter/update/9999/")
     url = reverse("tracking:multi_charter_add")
     self.assertEqual(url, "/tracking/mc/new/")
def test_wiki_link_update(client, data):
    public_url = reverse('wiki-links-detail', kwargs={"pk": data.public_wiki_link.pk})
    private_url1 = reverse('wiki-links-detail', kwargs={"pk": data.private_wiki_link1.pk})
    private_url2 = reverse('wiki-links-detail', kwargs={"pk": data.private_wiki_link2.pk})

    users = [
        None,
        data.registered_user,
        data.project_member_without_perms,
        data.project_member_with_perms,
        data.project_owner
    ]

    with mock.patch.object(OCCResourceMixin, "_validate_and_update_version") as _validate_and_update_version_mock:
            wiki_link_data = WikiLinkSerializer(data.public_wiki_link).data
            wiki_link_data["title"] = "test"
            wiki_link_data = json.dumps(wiki_link_data)
            results = helper_test_http_method(client, 'put', public_url, wiki_link_data, users)
            assert results == [401, 200, 200, 200, 200]

            wiki_link_data = WikiLinkSerializer(data.private_wiki_link1).data
            wiki_link_data["title"] = "test"
            wiki_link_data = json.dumps(wiki_link_data)
            results = helper_test_http_method(client, 'put', private_url1, wiki_link_data, users)
            assert results == [401, 200, 200, 200, 200]

            wiki_link_data = WikiLinkSerializer(data.private_wiki_link2).data
            wiki_link_data["title"] = "test"
            wiki_link_data = json.dumps(wiki_link_data)
            results = helper_test_http_method(client, 'put', private_url2, wiki_link_data, users)
            assert results == [401, 403, 403, 200, 200]
def test_wiki_link_patch(client, data):
    public_url = reverse('wiki-links-detail', kwargs={"pk": data.public_wiki_link.pk})
    private_url1 = reverse('wiki-links-detail', kwargs={"pk": data.private_wiki_link1.pk})
    private_url2 = reverse('wiki-links-detail', kwargs={"pk": data.private_wiki_link2.pk})

    users = [
        None,
        data.registered_user,
        data.project_member_without_perms,
        data.project_member_with_perms,
        data.project_owner
    ]

    with mock.patch.object(OCCResourceMixin, "_validate_and_update_version") as _validate_and_update_version_mock:
            patch_data = json.dumps({"title": "test"})
            results = helper_test_http_method(client, 'patch', public_url, patch_data, users)
            assert results == [401, 200, 200, 200, 200]

            patch_data = json.dumps({"title": "test"})
            results = helper_test_http_method(client, 'patch', private_url1, patch_data, users)
            assert results == [401, 200, 200, 200, 200]

            patch_data = json.dumps({"title": "test"})
            results = helper_test_http_method(client, 'patch', private_url2, patch_data, users)
            assert results == [401, 403, 403, 200, 200]
Beispiel #10
0
 def _wrapped_view(request, *args, **kwargs):
     mv = MessageVerification.objects.get(user=request.user)
     if not mv.verified:
         return redirect(reverse("accounts.views.sms_verify"))
     if not request.user.profile.activated:
         return redirect(reverse("accounts.views.not_activated"))
     return view_func(request, *args, **kwargs)
Beispiel #11
0
def export_result(request):
  response = {'status': -1, 'message': _('Exporting result failed.')}

  # Passed by check_document_access_permission but unused by APIs
  notebook = json.loads(request.POST.get('notebook', '{}'))
  snippet = json.loads(request.POST.get('snippet', '{}'))
  data_format = json.loads(request.POST.get('format', 'hdfs-file'))
  destination = json.loads(request.POST.get('destination', ''))
  overwrite = json.loads(request.POST.get('overwrite', False))

  api = get_api(request, snippet)

  if data_format == 'hdfs-file':
    if overwrite and request.fs.exists(destination):
      if request.fs.isfile(destination):
        request.fs.do_as_user(request.user.username, request.fs.rmtree, destination)
      else:
        raise ValidationError(_("The target path is a directory"))
    response['watch_url'] = api.export_data_as_hdfs_file(snippet, destination, overwrite)
    response['status'] = 0
  elif data_format == 'hive-table':
    notebook_id = notebook['id'] or request.GET.get('editor', request.GET.get('notebook'))
    response['watch_url'] = reverse('notebook:execute_and_watch') + '?action=save_as_table&notebook=' + str(notebook_id) + '&snippet=0&destination=' + destination
    response['status'] = 0
  elif data_format == 'hdfs-directory':
    notebook_id = notebook['id'] or request.GET.get('editor', request.GET.get('notebook'))
    response['watch_url'] = reverse('notebook:execute_and_watch') + '?action=insert_as_query&notebook=' + str(notebook_id) + '&snippet=0&destination=' + destination
    response['status'] = 0

  return JsonResponse(response)
 def make_request(self, request):
     """
     We need this to be a method and not a function, since we need to have
     a reference to the shop interface
     """
     order = self.shop.get_order(request)
     base_url = '%s://%s' % ('https' if request.is_secure() else 'http', request.get_host())
     signed_order = signing.dumps({'order_id': order.pk})
     xml_request = render_to_string('shop_sofortpayment/xml/new_transaction.xml', {
         'project_id': settings.SHOP_SOFORT_PROJECT_ID,
         'language_code': get_language(),
         'interface_version': 'django-shop-sofortpayment-' + __version__,
         'amount': order.order_total,
         'currency': settings.SHOP_SOFORT_CURRENCY,
         'order_number': order.pk,
         'user_name': order.billing_address_text,
         'success_url': '%s%s?s=%s' % (base_url, reverse('sofort_success'), signed_order),
         'notification_url': '%s%s?s=%s' % (base_url, reverse('sofort_notify'), signed_order),
         'abort_url': base_url + reverse('cart'),
         'customer_protection': '1' if settings.SHOP_SOFORT_ENABLE_CUSTOMER_PROTECTION else '0',
     })
     response = requests.post(
         settings.SHOP_SOFORT_API_ENDPOINT,
         data=xml_request.encode('utf-8'),
         headers={'Content-Type': 'application/xml; charset=UTF-8'},
         auth=(settings.SHOP_SOFORT_CUSTOMER_NUMBER, settings.SHOP_SOFORT_API_KEY),
     )
     if response.status_code == 200:
         doc = xmltodict.parse(response.content)
         transaction = SofortTransaction.objects.create(
             order=order,
             transaction_number=doc['new_transaction']['transaction'],
         )
         return HttpResponseRedirect(doc['new_transaction']['payment_url'])
     return render_to_response("shop_sofortpayment/payment.html", context)
Beispiel #13
0
    def test_votes(self):
        self.client.login(username='******', password='******')
        #User.objects.create(user=self.user, mailman_id=str(uuid.uuid1()))
        ## use a temp variable below because self.client.session is actually a
        ## property which returns a new instance en each call :-/
        #session = self.client.session
        #session["user_id"] = uuid.uuid1()
        #session.save()
        msg_hash = self._send_message()
        email = Email.objects.get(message_id="msg")
        email.vote(user=self.user, value=1)

        try:
            response = self.client.get(reverse("hk_user_votes"))
        except AttributeError:
            self.fail("Getting the votes should not fail if "
                      "the user has never voted yet\n%s" % format_exc())
        self.assertEqual(response.status_code, 200)
        self.assertContains(response,
            '<a href="{}">Dummy message</a>'.format(
                reverse("hk_message_index", args=("*****@*****.**", msg_hash)
             )), count=2, html=True)
        self.assertContains(response, 'action="{}">'.format(
                reverse("hk_message_vote", args=("*****@*****.**", msg_hash)
             )), count=2, html=False)
        self.assertContains(response, "Dummy Sender", count=2, html=False)
Beispiel #14
0
    def __init__(self, *args, **kwargs):
        self.form_data = kwargs.pop('provider_data', None)

        super(AmazonForm, self).__init__(*args, **kwargs)

        try:
            self.fields['name'].initial = self.form_data.get('name')
            self.fields['access_key'].initial = self.form_data.get('access_key')
            self.fields['secret_key'].initial = self.form_data.get('secret_key')
            self.fields['regions'].initial = self.form_data.get('regions')

            self.fields['regions'].widget.attrs.update({
                'tags-dropdown': '', 
                'data-size': 480,
                'read-only': True,
                'data-tags-url': reverse('api_cloudservers_get_amazon_regions'),
                'data-url': reverse('api_cloudservers_get_amazon_regions'),
            })

        except:
            self.fields['regions'].widget.attrs.update({
                'tags-dropdown': '', 
                'data-size': 480,
                'data-tags-url': reverse('api_cloudservers_get_amazon_regions'),
            })
Beispiel #15
0
 def __init__(self):
     self.current_site = Site.objects.get_current()
     self.site_url = '%s://%s' % (PROTOCOL, self.current_site.domain)
     self.blog_url = '%s%s' % (self.site_url,
                               reverse('objectapp_gbobject_archive_index'))
     self.blog_feed = '%s%s' % (self.site_url,
                                reverse('objectapp_gbobject_latest_feed'))
Beispiel #16
0
def check_relationships(test, url, data_source, data_target):
    response = test.client.post(url, data_source)
    # We check that the request is correct
    test.assertEqual(response.status_code, 201)
    source_slug = response.data['slug']
    response = test.client.post(url, data_target)
    # We check that the request is correct
    test.assertEqual(response.status_code, 201)
    target_slug = response.data['slug']
    data = {'name': test.relationshiptype_name,
            'source': source_slug,
            'target': target_slug}
    url = reverse("api_relationship_types", args=[test.graph_slug])
    # Then, we check the post method
    response = test.client.post(url, data)
    data = {'name': test.relationshiptype_name}
    relationshiptype_name = response.data['name']
    test.assertEqual(relationshiptype_name, test.relationshiptype_name)
    response = test.client.get(url)
    relationshiptype_slug = response.data[0]['slug']
    url = reverse("api_relationship_type",
                  args=[test.graph_slug, relationshiptype_slug])
    response = test.client.get(url)
    test.assertEqual(response.status_code, 200)
    test.assertEqual(response.data['name'], test.relationshiptype_name)
    test.assertEqual(response.data['rels_info'], [])
    return (relationshiptype_slug, source_slug, target_slug)
    def get_absolute_url(self, language=None, fallback=True):
        try:
            if self.is_home():
                return reverse('pages-root')
        except NoHomeFound:
            pass
        if settings.CMS_FLAT_URLS:
            path = self.get_slug(language, fallback)
        else:
            path = self.get_path(language, fallback)
            if hasattr(self, "home_cut_cache") and self.home_cut_cache:
                if not self.get_title_obj_attribute("has_url_overwrite", language, fallback) and path:
                    path = "/".join(path.split("/")[1:])
            else:    
                home_pk = None
                try:
                    home_pk = self.home_pk_cache
                except NoHomeFound:
                    pass
                ancestors = self.get_cached_ancestors(ascending=True)
                if self.parent_id and ancestors[-1].pk == home_pk and not self.get_title_obj_attribute("has_url_overwrite", language, fallback) and path:
                    path = "/".join(path.split("/")[1:])
            
        if settings.CMS_DBGETTEXT and settings.CMS_DBGETTEXT_SLUGS:
            path = '/'.join([ugettext(p) for p in path.split('/')])

        return urljoin(reverse('pages-root'), path)
Beispiel #18
0
    def test_channel_edit_child(self):
        channel = Channel.objects.get(slug='testing')
        response = self.client.get(
            reverse('manage:channel_edit', args=(channel.pk,)),
        )
        eq_(response.status_code, 200)
        choices = (
            response.content
            .split('name="parent"')[1]
            .split('</select>')[0]
        )
        ok_('Main' in choices)
        # you should not be able to self-reference
        ok_('Testing' not in choices)

        main = Channel.objects.get(slug='main')
        response = self.client.post(
            reverse('manage:channel_edit', args=(channel.pk,)),
            {
                'name': 'Different',
                'slug': 'different',
                'description': '<p>Other things</p>',
                'parent': main.pk,
                'feed_size': 10,
            }
        )
        eq_(response.status_code, 302)
        channel = Channel.objects.get(slug='different')
        eq_(channel.parent, main)

        # now expect two links to "Main" on the channels page
        response = self.client.get(reverse('manage:channels'))
        eq_(response.status_code, 200)
        view_url = reverse('main:home_channels', args=(main.slug,))
        eq_(response.content.count(view_url), 2)
Beispiel #19
0
    def test_api_nodes_delete(self):
        # # Creating the nodetype
        data = {'name': self.nodetype_name}
        url = reverse("api_node_types", args=[self.graph_slug])
        nodetype_slug = check_nodes_get(self, url, data)
        # # Creating the property for the nodetype
        url = reverse("api_node_type_schema_properties",
                      args=[self.graph_slug, nodetype_slug])
        property_name = 'prop_name'
        property_datatype = 'default'
        property_data = {
            'key': property_name,
            'datatype': property_datatype
        }
        create_property(self, url, property_data, property_name)
        # # Creating the nodes
        url = reverse("api_nodes",
                      args=[self.graph_slug, nodetype_slug])
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.data['nodes'], [])

        node_name1 = "nodeName1"
        node_data1 = {property_name: node_name1}
        node_name2 = "nodeName2"
        node_data2 = {property_name: node_name2}
        nodes_list = []
        nodes_list.append(node_data1)
        nodes_list.append(node_data2)
        nodes_ids = create_nodes(self, url, nodes_list)
        self.assertEqual(len(nodes_ids), 2)

        # # Deleting the nodes
        delete_nodes(self, url, nodes_ids)
Beispiel #20
0
    def test_delete_member(self):
        " Delete member from group "
        self.client.login(username='******', password='******')

        response = self.client.get(reverse('project-member-delete', kwargs = {'model_slug': 'busy-lizzy', 'member_slug': 'jane'}))

        self.assertRedirects(response, reverse('project-detail', kwargs = {'slug': 'busy-lizzy'}), target_status_code=200)
Beispiel #21
0
    def test_private_pages_auth(self):
        """Make sure pages that do require login work."""
        auth_pages = (
            reverse('index'),
        )

        # These are pages that should just load when the user is logged in
        # (no data needed)
        simple_auth_pages = (
            reverse('index'),
        )

        # need an activated user
        self.test_create_account()

        # Create a new session
        self.client = Client()

        # Not logged in.  Should redirect to login.
        print('Not logged in')
        for page in auth_pages:
            print("Checking '{0}'".format(page))
            self.check_page_get(page, expected=302)

        # Logged in should work.
        self.login(self.email, self.pw)

        print('Logged in')
        for page in simple_auth_pages:
            print("Checking '{0}'".format(page))
            self.check_page_get(page, expected=200)
Beispiel #22
0
    def test_task_history(self):
        self.test_add_task()

        url = reverse("task:add_tasklist", kwargs={
            "username": TEST_DATA['user']['username'],
        })
        response = self.client.post(url, TEST_DATA['tasklist_2'], follow=True)

        url = reverse("task:edit_task", kwargs={
            "username": TEST_DATA['user']['username'],
            "task_id": 1,
        })
        response = self.client.post(url, TEST_DATA['task_edit_for_history'], follow=True)

        url = reverse("task:view_task", kwargs={
            "username": TEST_DATA['user']['username'],
            "task_id": 1,
        })
        response = self.client.get(url)

        self.assertContains(response, TEST_DATA['task']['name'])
        self.assertContains(response, TEST_DATA['task']['description'])
        self.assertContains(response, TEST_DATA['task_edit_for_history']['name'])
        self.assertContains(response, TEST_DATA['task_edit_for_history']['description'])
        self.assertContains(response, TEST_DATA['tasklist']['name'])
        self.assertContains(response, TEST_DATA['tasklist_2']['name'])
Beispiel #23
0
    def test_reg_code_with_multiple_courses_and_checkout_scenario(self):
        self.add_reg_code(self.course_key)

        # Two courses in user shopping cart
        self.login_user()
        PaidCourseRegistration.add_to_order(self.cart, self.course_key)
        PaidCourseRegistration.add_to_order(self.cart, self.testing_course.id)
        self.assertEquals(self.cart.orderitem_set.count(), 2)

        resp = self.client.post(reverse('shoppingcart.views.use_code'), {'code': self.reg_code})
        self.assertEqual(resp.status_code, 200)

        resp = self.client.get(reverse('shoppingcart.views.show_cart', args=[]))
        self.assertIn('Check Out', resp.content)
        self.cart.purchase(first='FirstNameTesting123', street1='StreetTesting123')

        resp = self.client.get(reverse('shoppingcart.views.show_receipt', args=[self.cart.id]))
        self.assertEqual(resp.status_code, 200)

        ((template, context), _) = render_mock.call_args  # pylint: disable=W0621
        self.assertEqual(template, 'shoppingcart/receipt.html')
        self.assertEqual(context['order'], self.cart)
        self.assertEqual(context['order'].total_cost, self.testing_cost)

        course_enrollment = CourseEnrollment.objects.filter(user=self.user)
        self.assertEqual(course_enrollment.count(), 2)
Beispiel #24
0
    def test_reg_code_free_discount_with_multiple_courses_in_cart(self, info_log):

        reg_item = self.add_course_to_user_cart()
        self.add_reg_code(self.course_key)
        cert_item = CertificateItem.add_to_order(self.cart, self.verified_course_key, self.cost, 'honor')
        self.assertEquals(self.cart.orderitem_set.count(), 2)

        resp = self.client.post(reverse('shoppingcart.views.use_code'), {'code': self.reg_code})
        self.assertEqual(resp.status_code, 200)

        # unit_cost should be 0 for that particular course for which registration code is registered
        items = self.cart.orderitem_set.all().select_subclasses()
        for item in items:
            if item.id == reg_item.id:
                self.assertEquals(item.unit_cost, 0)
            elif item.id == cert_item.id:
                self.assertEquals(item.list_price, None)

        # Delete the discounted item, corresponding reg code redemption should be removed for that particular item
        resp = self.client.post(reverse('shoppingcart.views.remove_item', args=[]),
                                {'id': reg_item.id})

        self.assertEqual(resp.status_code, 200)
        self.assertEquals(self.cart.orderitem_set.count(), 1)
        info_log.assert_called_with(
            'Registration code "{0}" redemption entry removed for user "{1}" for order item "{2}"'.format(self.reg_code, self.user, reg_item.id))
Beispiel #25
0
 def test_postpay_callback_success(self):
     postpay_mock.return_value = {'success': True, 'order': self.cart}
     self.login_user()
     resp = self.client.post(reverse('shoppingcart.views.postpay_callback', args=[]))
     self.assertEqual(resp.status_code, 302)
     self.assertEqual(urlparse(resp.__getitem__('location')).path,
                      reverse('shoppingcart.views.show_receipt', args=[self.cart.id]))
Beispiel #26
0
    def get_context_data(self, **kwargs):
        context = super(ProjectDetailView, self).get_context_data(**kwargs)

        project = self.get_object()
        context['versions'] = Version.objects.public(
            user=self.request.user, project=project)
        context['filter'] = VersionSlugFilter(self.request.GET,
                                              queryset=context['versions'])

        protocol = 'http'
        if self.request.is_secure():
            protocol = 'https'

        context['badge_url'] = "%s://%s%s?version=%s" % (
            protocol,
            settings.PRODUCTION_DOMAIN,
            reverse('project_badge', args=[project.slug]),
            project.get_default_version(),
        )
        context['site_url'] = "%s://%s%s?badge=%s" % (
            protocol,
            settings.PRODUCTION_DOMAIN,
            reverse('projects_detail', args=[project.slug]),
            project.get_default_version(),
        )

        return context
Beispiel #27
0
    def dispatch(self, request, organization_slug):
        from sentry.auth.helper import AuthHelper
        helper = AuthHelper.get_for_request(request)

        # SP initiated authentication, request helper is provided
        if helper:
            from sentry.web.frontend.auth_provider_login import AuthProviderLoginView
            sso_login = AuthProviderLoginView()
            return sso_login.handle(request)

        # IdP initiated authentication. The organizatio_slug must be valid and
        # an auth provider must exist for this organization to proceed with
        # IdP initiated SAML auth.
        try:
            organization = Organization.objects.get(slug=organization_slug)
        except Organization.DoesNotExist:
            messages.add_message(request, messages.ERROR, ERR_NO_SAML_SSO)
            return self.redirect(reverse('sentry-login'))

        try:
            auth_provider = AuthProvider.objects.get(organization=organization)
        except AuthProvider.DoesNotExist:
            messages.add_message(request, messages.ERROR, ERR_NO_SAML_SSO)
            return self.redirect(reverse('sentry-login'))

        helper = AuthHelper(
            request=request,
            organization=organization,
            auth_provider=auth_provider,
            flow=AuthHelper.FLOW_LOGIN,
        )

        helper.init_pipeline()
        return helper.current_step()
Beispiel #28
0
def edit_snippet(request, snippet_id=None):
    "Edits an existing code snippet"

    if snippet_id is None:
        raise Http404()

    template_name = "snippets/edit.html"

    if request.method == "POST":
        form = CodeSnippetForm(request.POST)
        if form.is_valid():
            snippet = get_snippet_or_404(snippet_id)
            snippet = copy_snippet_from_form(form, snippet=snippet)
            snippet.put()
            index_snippet_with_search(snippet)

            return HttpResponseRedirect(reverse("snippets:snippet-detail", kwargs={"snippet_id": snippet.key().id()}))
    else:
        initial_data = {}
        snippet = get_snippet_or_404(snippet_id)
        initial_data.update(db.to_dict(snippet))
        form = CodeSnippetForm(initial=initial_data, auto_id=False)

    ctx = {}
    ctx["form"] = form
    ctx["form_action"] = reverse("snippets:edit-snippet", kwargs={"snippet_id": snippet_id})

    return render_to_response(template_name, context_instance=RequestContext(request, ctx))
Beispiel #29
0
def access_group_projects(request, team, group_id):
    try:
        group = AccessGroup.objects.get(team=team, id=group_id)
    except AccessGroup.DoesNotExist:
        return HttpResponseRedirect(reverse('sentry-manage-access-groups', args=[team.slug]))

    form = NewAccessGroupProjectForm(group, request.POST or None)
    if form.is_valid():
        project = form.cleaned_data['project']
        group.projects.add(project)

        messages.add_message(request, messages.SUCCESS,
            _('%s was added to this access group.') % (project.name,))

        return HttpResponseRedirect(reverse('sentry-access-group-projects', args=[team.slug, group.id]))

    group_list = list(AccessGroup.objects.filter(team=team))
    for g_ in group_list:
        g_.team = team

    context = csrf(request)
    context.update({
        'group': group,
        'form': form,
        'project_list': group.projects.all(),
        'group_list': group_list,
        'page': 'projects',
        'SUBSECTION': 'groups',
    })

    return render_with_team_context(team, 'sentry/teams/groups/projects.html', context, request)
Beispiel #30
0
    def test_courseware_page_unfulfilled_prereqs(self):
        """
        Test courseware access when a course has pre-requisite course yet to be completed
        """
        seed_milestone_relationship_types()
        pre_requisite_course = CourseFactory.create(org="edX", course="900", run="test_run")

        pre_requisite_courses = [unicode(pre_requisite_course.id)]
        course = CourseFactory.create(
            org="edX", course="1000", run="test_run", pre_requisite_courses=pre_requisite_courses
        )
        set_prerequisite_courses(course.id, pre_requisite_courses)

        test_password = "******"
        user = UserFactory.create()
        user.set_password(test_password)
        user.save()
        self.login(user.email, test_password)
        CourseEnrollmentFactory(user=user, course_id=course.id)

        url = reverse("courseware", args=[unicode(course.id)])
        response = self.client.get(url)
        self.assertRedirects(response, reverse("dashboard"))
        self.assertEqual(response.status_code, 302)

        fulfill_course_milestone(pre_requisite_course.id, user)
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)
Beispiel #31
0
def messaging_compose(request, response_format='html'):
    "New message page"

    user = request.user.get_profile()

    if request.POST:
        if not 'cancel' in request.POST:
            message = Message()
            message.author = user.get_contact()
            if not message.author:
                return user_denied(
                    request,
                    message=
                    "You can't send message without a Contact Card assigned to you.",
                    response_format=response_format)

            form = MessageForm(request.user.get_profile(),
                               None,
                               None,
                               request.POST,
                               instance=message)
            if form.is_valid():
                message = form.save()
                message.recipients.add(user.get_contact())
                message.set_user_from_request(request)
                message.read_by.add(user)
                try:
                    # if email entered create contact and add to recipients
                    if 'multicomplete_recipients' in request.POST and request.POST[
                            'multicomplete_recipients']:
                        try:
                            conf = ModuleSetting.get_for_module(
                                'treeio.messaging', 'default_contact_type')[0]
                            default_contact_type = ContactType.objects.get(
                                pk=long(conf.value))
                        except Exception:
                            default_contact_type = None
                        emails = request.POST[
                            'multicomplete_recipients'].split(',')
                        for email in emails:
                            emailstr = unicode(email).strip()
                            if re.match(
                                    '[a-zA-Z0-9+_\-\.]+@[0-9a-zA-Z][.-0-9a-zA-Z]*.[a-zA-Z]+',
                                    emailstr):
                                contact, created = Contact.get_or_create_by_email(
                                    emailstr,
                                    contact_type=default_contact_type)
                                message.recipients.add(contact)
                                if created:
                                    contact.set_user_from_request(request)
                except:
                    pass
                # send email to all recipients
                message.send_email()

                return HttpResponseRedirect(reverse('messaging'))
        else:
            return HttpResponseRedirect(reverse('messaging'))

    else:
        form = MessageForm(request.user.get_profile(), None)

    context = _get_default_context(request)
    context.update({'form': form})

    return render_to_response('messaging/message_compose',
                              context,
                              context_instance=RequestContext(request),
                              response_format=response_format)
Beispiel #32
0
 def test_unknown_decor_detail(self):
     decor_id = 0
     url = reverse('decor-detail', kwargs={'pk': decor_id})
     response = self.client.get(url)
     assert_that(response, has_status_code(status.HTTP_404_NOT_FOUND))
Beispiel #33
0
 def test_known_decor_detail(self):
     decor_id = 1
     url = reverse('decor-detail', kwargs={'pk': decor_id})
     response = self.client.get(url)
     assert_that(response, has_status_code(status.HTTP_200_OK))
     assert_that(response.data['id'], equal_to(decor_id))
Beispiel #34
0
 def test_list_decors(self):
     url = reverse('decor-list')
     response = self.client.get(url)
     assert_that(response, has_status_code(status.HTTP_200_OK))
     assert_that(response.data, has_length(len(get_all_decor())))
Beispiel #35
0
 def __init__(self, **kwargs):
     super(EditUser, self).__init__(**kwargs)
     self.template_name = 'users/new.html'
     self.object = User
     self.form_class = EditUserProfileForm
     self.success_url = reverse('list_users_page')
Beispiel #36
0
 def _form_valid(self):
     self.form.save()
     message = "%s was successfully updated" % self.form.cleaned_data['username']
     messages.success(self.request, message)
     return HttpResponseRedirect(reverse("list_users_page"))
Beispiel #37
0
def messaging_view(request, message_id, response_format='html'):
    "Single message page"

    message = get_object_or_404(Message, pk=message_id)
    user = request.user.get_profile()

    if not user.has_permission(message):
        return user_denied(request,
                           message="You don't have access to this Message",
                           response_format=response_format)

    message.read_by.add(user)

    if request.POST and request.POST.get('body', False):
        "Unread message"

        reply = Message()
        reply.author = user.get_contact()
        if not reply.author:
            return user_denied(
                request,
                message=
                "You can't send message without a Contact Card assigned to you.",
                response_format=response_format)
        reply.reply_to = message
        form = MessageReplyForm(user,
                                message.stream_id,
                                message,
                                request.POST,
                                instance=reply)
        if form.is_valid():
            reply = form.save()
            reply.set_user_from_request(request)
            # Add author to recipients
            reply.recipients.add(reply.author)
            message.read_by.clear()

            try:
                # if email entered create contact and add to recipients
                if 'multicomplete_recipients' in request.POST and request.POST[
                        'multicomplete_recipients']:
                    try:
                        conf = ModuleSetting.get_for_module(
                            'treeio.messaging', 'default_contact_type')[0]
                        default_contact_type = ContactType.objects.get(
                            pk=long(conf.value))
                    except Exception:
                        default_contact_type = None
                    emails = request.POST['multicomplete_recipients'].split(
                        ',')
                    for email in emails:
                        emailstr = unicode(email).strip()
                        if re.match(
                                '[a-zA-Z0-9+_\-\.]+@[0-9a-zA-Z][.-0-9a-zA-Z]*.[a-zA-Z]+',
                                emailstr):
                            contact, created = Contact.get_or_create_by_email(
                                emailstr, contact_type=default_contact_type)
                            reply.recipients.add(contact)
                            if created:
                                contact.set_user_from_request(request)
            except:
                pass

            # Add each recipient of the reply to the original message
            for recipient in reply.recipients.all():
                message.recipients.add(recipient)

            # send email to all recipients
            reply.send_email()

            return HttpResponseRedirect(
                reverse('messaging_message_view', args=[message.id]))

    else:
        form = MessageReplyForm(request.user.get_profile(), message.stream_id,
                                message)

    replies = Object.filter_by_request(
        request,
        Message.objects.filter(reply_to=message).order_by('date_created'))

    context = _get_default_context(request)
    context.update({'message': message, 'messages': replies, 'form': form})

    return render_to_response('messaging/message_view',
                              context,
                              context_instance=RequestContext(request),
                              response_format=response_format)
Beispiel #38
0
                             _("E-mails fetched successfully."),
                             fail_silently=True)
    except Exception, e:
        print e
        try:
            messages.add_message(
                request,
                messages.ERROR,
                _("Failed to retrieve messages for this stream. Please check stream settings"
                  ),
                fail_silently=True)
        except:
            pass

    return HttpResponseRedirect(
        reverse('messaging_stream_view', args=[stream.id]))


@handle_response_format
@treeio_login_required
def stream_delete(request, stream_id, response_format='html'):
    "Delete stream page"

    stream = get_object_or_404(MessageStream, pk=stream_id)
    if not request.user.get_profile().has_permission(stream, mode="w"):
        return user_denied(request,
                           message="You don't have access to this Stream",
                           response_format=response_format)

    if request.POST:
        if 'delete' in request.POST:
Beispiel #39
0
 def get_absolute_url(self):
     return urlresolvers.reverse(
             'show_creator_award',
             kwargs={'creator_award_id': self.id})
Beispiel #40
0
def stream_view(request, stream_id, response_format='html'):
    "Stream view page"

    user = request.user.get_profile()

    stream = get_object_or_404(MessageStream, pk=stream_id)
    if not request.user.get_profile().has_permission(stream):
        return user_denied(request,
                           message="You don't have access to this Stream",
                           response_format=response_format)

    if request.user.get_profile().has_permission(stream, mode='x'):
        if request.POST:
            message = Message()
            message.author = user.get_contact()
            if not message.author:
                return user_denied(
                    request,
                    message=
                    "You can't send message without a Contact Card assigned to you.",
                    response_format=response_format)

            form = MessageForm(request.user.get_profile(),
                               None,
                               None,
                               request.POST,
                               instance=message)
            if form.is_valid():
                message = form.save()
                message.recipients.add(user.get_contact())
                message.set_user_from_request(request)
                message.read_by.add(user)
                try:
                    # if email entered create contact and add to recipients
                    if 'multicomplete_recipients' in request.POST and request.POST[
                            'multicomplete_recipients']:
                        try:
                            conf = ModuleSetting.get_for_module(
                                'treeio.messaging', 'default_contact_type')[0]
                            default_contact_type = ContactType.objects.get(
                                pk=long(conf.value))
                        except Exception:
                            default_contact_type = None
                        emails = request.POST[
                            'multicomplete_recipients'].split(',')
                        for email in emails:
                            emailstr = unicode(email).strip()
                            if re.match(
                                    '[a-zA-Z0-9+_\-\.]+@[0-9a-zA-Z][.-0-9a-zA-Z]*.[a-zA-Z]+',
                                    emailstr):
                                contact, created = Contact.get_or_create_by_email(
                                    emailstr,
                                    contact_type=default_contact_type)
                                message.recipients.add(contact)
                                if created:
                                    contact.set_user_from_request(request)
                except:
                    pass
                # send email to all recipients
                message.send_email()

                return HttpResponseRedirect(
                    reverse('messaging_stream_view', args=[stream.id]))
        else:
            form = MessageForm(request.user.get_profile(), stream_id)

    else:
        form = None

    objects = Object.filter_by_request(
        request,
        Message.objects.filter(reply_to__isnull=True,
                               stream=stream).order_by('-date_created'))
    context = _get_default_context(request)
    context.update({'messages': objects, 'form': form, 'stream': stream})

    return render_to_response('messaging/stream_view',
                              context,
                              context_instance=RequestContext(request),
                              response_format=response_format)
Beispiel #41
0
 def get_absolute_url(self):
     return urlresolvers.reverse(
             'show_creator_art_influence',
             kwargs={'creator_art_influence_id': self.id})
Beispiel #42
0
 def get_absolute_url(self):
     return urlresolvers.reverse(
             'show_creator_non_comic_work',
             kwargs={'creator_non_comic_work_id': self.id})
Beispiel #43
0
 def get_absolute_url(self):
     return reverse("entry_detail", kwargs={"slug": self.slug})
Beispiel #44
0
 def get_absolute_url(self):
     return urlresolvers.reverse(
             'show_creator_membership',
             kwargs={'creator_membership_id': self.id})
Beispiel #45
0
 def get_absolute_url(self):
     return reverse('solution_statement', kwargs={'task_id': self.id})
Beispiel #46
0
def delete_images(request):
    """
    Deletes images which are passed via HTTP query.
    """
    Image.objects.filter(pk__in=request.POST.getlist("images")).delete()
    return HttpResponseRedirect(reverse("lfs_manage_global_images"))
Beispiel #47
0
    def get_absolute_url(self):
        """Obtiene la url relacionada con un :class:`Plan`"""

        return reverse('contracts-plan', args=[self.id])
Beispiel #48
0
 def put_notice(self, data):
     url = reverse('myuw_notices_api')
     return self.client.put(url, data)
Beispiel #49
0
    def get_absolute_url(self):

        return reverse('contrato-index')
Beispiel #50
0
    def get_absolute_url(self):
        """Obtiene la url relacionada con un :class:`Beneficiario`"""

        return reverse('contrato', args=[self.contrato.id])
 def test_should_have_water_polls_in_context_of_schedule_view(self):
     self.client.login(username=self.user.username, password='******')
     response = self.client.get(reverse(schedule_water_polls))
     self.assertEqual(200, response.status_code)
Beispiel #52
0
    def get_absolute_url(self):
        """Obtiene la url relacionada con un :class:`Paciente`"""

        return reverse('contracts-vendedor', args=[self.id])
Beispiel #53
0
 def location(self, item):
     return reverse(item) 
 def test_should_enforce_login_on_schedule_water_poll_view(self):
     response = self.client.get(reverse(schedule_water_polls))
     self.assertEqual(302, response.status_code)
Beispiel #55
0
    if (request.POST.get('signed_request')
            and '.' in request.POST['signed_request']):
        signature, b64blob = request.POST['signed_request'].split('.')[:2]
        if len(b64blob) % 4 != 0:
            # Python requires padding for 4 byte chunks.
            # http://stackoverflow.com/questions/3302946/how-to-base64-url-decode-in-python
            b64blob = '%s==' % b64blob
        try:
            payload = simplejson.loads(base64.b64decode(b64blob))
        except (TypeError, ValueError), exc:
            log.exception('Invalid payload:')
        # TODO(Kumar) validate payload w/ signature

    # Bust javascript cache when developing:
    cache_stub = settings.DEBUG and str(time.time()) or ''
    channel_url = absolutify(reverse('fbapp.channel'))
    chirp_icon_url = '%s%sfbapp/img/Icon-50.png' % (settings.SITE_URL,
                                                    settings.MEDIA_URL)
    context.update(
        dict(cache_stub=cache_stub,
             app_id=app_id,
             channel_url=channel_url,
             chirp_icon_url=chirp_icon_url))
    context.setdefault('show_live_fb', True)
    context.setdefault('in_page_tab', False)
    context.setdefault('in_openwebapp', False)
    context.setdefault('root_div_id', 'fb-root')
    context.setdefault('connect_to_facebook', True)
    context.setdefault('api_source', 'facebook')
    context.setdefault('app_url', absolutify(reverse('fbapp.canvas')))
    response = render_to_response(template,
Beispiel #56
0
def old_add2_redirect(request, a, b):
    return HttpResponseRedirect(reverse('add2', args=(a, b)))
Beispiel #57
0
 def test_menu_search(self):
     rendered = self.menu_search()
     self.assertIn(reverse('wagtailadmin_pages:search'), rendered)
Beispiel #58
0
def get_auth_url(request, redirect_url = None):
    return reverse(ldap_login_view)
Beispiel #59
0
 def get_absolute_url(self):
     return reverse('blog.views.post', args=[self.slug])
Beispiel #60
0
 def wrapper(request,*view_args,**view_kwargs):
     if request.session.has_key('islogin'):
         #用户已经登录
         return view_func(request,*view_args,**view_kwargs)
     else:
         return redirect(reverse('user:login'))