Пример #1
0
 def get_context_data(self, *args, **kwargs):
     context = super().get_context_data(*args, **kwargs)
     self.form.full_clean()
     search_params = {k: self.form.data[k] for k, v in
                      self.form.cleaned_data.items()
                      if v not in [None, '']}
     if hasattr(self, 'order'):
         search_params['order'] = self.order
         context['order'] = self.order
     else:
         context['order'] = self.get_model()._meta.ordering[0]
     if len(search_params):
         context['querystring'] = urlencode(search_params)
         try:
             search_params.pop('order')
         except Exception:
             pass
         context['querystring_without_order'] = urlencode(search_params)
         if len(context['querystring_without_order']) > 0:
             context['querystring_without_order'] += '&'
     else:
         context['querystring_without_order'] = ''
     if self.form.is_submitted():
         context['add_search_form'] = SavedSearchForm()
         context['saved_search_url'] = resolve_url(
             'contacts:search-save',
             type=self.model._meta.model_name,
         ) + '?' + context['querystring']
     return context
Пример #2
0
def construct_url(url, query_dict = None, clean=False):
    parse_result = urlparse(url)
    
    query = {}
    if not clean:
        if len(parse_result.query) > 0:
            query = parse_qs(parse_result.query)
            
            for key, value in query.iteritems():
                query[key] = value
      
    
    if query_dict is not None:
        for key, value in query_dict.iteritems():
            if value is not None:
                query[key] = [value]
            
    if len(query.keys()) > 0:
        _query= []
        for key, values in query.iteritems():
            if len(values) == 1:
                _query.append(urlencode({key: values[0]}))
            else:
                for value in values:
                    _query.append(urlencode({key: value}))
                
        query = '&'.join(_query)
    else:
        query = None
        
    return "%s%s%s" % ( parse_result.path, "?%s" % query if query is not None else '', "#%s" % parse_result.fragment if len(parse_result.fragment) > 0 else '')
Пример #3
0
def search(request):
    pagesize = 30  # per Flickr API TOS

    query = request.GET.get('q', '') or request.POST.get('q', '')
    try:
        page = int(request.GET.get('p', 1))
    except ValueError:
        page = 1

    f = FlickrSearch()
    results = f.search(query, page, pagesize) if query else None

    if results['records']:
        # Map URLs to IDs and find out which ones are already selected
        urls = [r['record_url'] for r in results['records']]
        ids = dict(Record.objects.filter(source__in=urls, manager='flickr').values_list('source', 'id'))
        selected = request.session.get('selected_records', ())

        for r in results['records']:
            r['id'] = ids.get(r['record_url'])
            r['selected'] = r['id'] in selected

    pages = int(math.ceil(float(results['hits']) / pagesize)) if results else 0
    prev_page_url = "?" + urlencode((('q', query), ('p', page - 1))) if page > 1 else None
    next_page_url = "?" + urlencode((('q', query), ('p', page + 1))) if page < pages else None

    return render_to_response('flickr-results.html',
                              {'query': query,
                               'results': results,
                               'page': page,
                               'pages': pages,
                               'prev_page': prev_page_url,
                               'next_page': next_page_url,
                              },
                              context_instance=RequestContext(request))
Пример #4
0
def search(request):

    pagesize = 50

    query = request.GET.get('q', '') or request.POST.get('q', '')
    try:
        page = int(request.GET.get('p', 1))
    except ValueError:
        page = 1

    a = ArtstorSearch()

    try:
        results = a.search(query, page, pagesize) if query else None
        failure = False
    except urllib2.HTTPError:
        results = None
        failure = True


    pages = int(math.ceil(float(results['hits']) / pagesize)) if results else 0
    prev_page_url = "?" + urlencode((('q', query), ('p', page - 1))) if page > 1 else None
    next_page_url = "?" + urlencode((('q', query), ('p', page + 1))) if page < pages else None

    return render_to_response('artstor-results.html',
                          {'query': query,
                           'results': results,
                           'page': page,
                           'failure': failure,
                           'pages': pages,
                           'prev_page': prev_page_url,
                           'next_page': next_page_url,
                           },
                          context_instance=RequestContext(request))
Пример #5
0
    def assert_pic_is_correct(self, cd_key, pic, disc_pic_nbr=None):
        """Assert that the CD has the correct picture."""
        assert cd_key in CDS_DATA
        assert pic in ('cover', 'disc')
        if pic == 'disc':
            assert disc_pic_nbr in (1, 2)

        cd = get_cd(cd_key=cd_key)
        cd_data = CDS_DATA[cd_key]

        if pic == 'cover':
            picture_path = cd_data['cover_path']
        else:  # disc
            picture_path = cd_data['disc%s_path' % disc_pic_nbr]

        download_url = reverse('db_file_storage.download_file')
        if pic == 'cover':
            download_url += '?' + urlencode({'name': cd.cover.name})
        else:  # disc
            download_url += '?' + urlencode({'name': cd.disc.name})

        response = self.client.get(download_url)

        with open(picture_path, 'rb') as pic_file:
            # Assert that the contents of the saved picture are correct
            self.assertEqual(pic_file.read(), response.content)

        # Assert that the mimetype of the saved picture is correct
        self.assertEqual(
            mimetypes.guess_type(picture_path)[0],
            response['Content-Type']
        )
Пример #6
0
 def test_macos_apps_sha_256_search(self):
     self.log_user_in()
     # cert signature
     response = self.client.get("{}?{}".format(
         reverse("inventory:macos_apps"),
         urlencode({"sha_256": "7afc9d01a62f03a2de9637936d4afe68090d2de18d03f29c88cfb0b1ba63587f"})
     ))
     self.assertContains(response, "1 macOS application")
     # binary signature
     response = self.client.get("{}?{}".format(
         reverse("inventory:macos_apps"),
         urlencode({"sha_256": 64 * "a"})
     ))
     self.assertContains(response, "1 macOS application")
     # bad sha 256
     response = self.client.get("{}?{}".format(
         reverse("inventory:macos_apps"),
         urlencode({"sha_256": 64 * "z"})
     ))
     self.assertFormError(response, "search_form", "sha_256", "Enter a valid sha256.")
     # another sha 256
     response = self.client.get("{}?{}".format(
         reverse("inventory:macos_apps"),
         urlencode({"sha_256": 64 * "f"})
     ))
     self.assertContains(response, "0 macOS applications")
Пример #7
0
    def add_query_for_user(self, user, query_string, hits):
        parsed_query = urlparse.parse_qs(urlencode(dict(query_string.items())))

        for key, value in parsed_query.items():
            parsed_query[key] = ' '.join(value)

        if 'q' in query_string:
            # Is a simple query

            if not query_string['q']:
                # Don't store empty simple searches
                return
            else:
                # Cleanup query string and only store the q parameter
                parsed_query = {'q': parsed_query['q']}

        if parsed_query and not isinstance(user, AnonymousUser):
            # If the URL query has at least one variable with a value
            new_recent, created = self.model.objects.get_or_create(user=user, query=urlencode(parsed_query), defaults={'hits': hits})
            if not created:
                new_recent.hits = hits
                new_recent.save()

            for recent_to_delete in self.model.objects.filter(user=user)[RECENT_COUNT:]:
                recent_to_delete.delete()
Пример #8
0
    def test_select_active_organization(self):
        redirect_url = (
            "http://testserver/")
        url = '%s?%s' % (reverse(
            'organizations:select-active', args=(self.organization.slug,)),
            urlencode({'next': redirect_url}))

        self.client.logout()
        self.assertRedirects(self.client.get(url), '%s?next=%s' % (
            reverse('login'), urlquote(url)))

        self.client.login(username=self.user.username, password='******')
        response = self.client.get(url)
        self.assertRedirects(response, redirect_url)
        self.assertEqual(
            self.client.session.get(ORGANIZATION_SESSION_KEY),
            self.organization.pk)

        # check redirect for missing next param and external redirect
        url = reverse(
            'organizations:select-active', args=(self.organization.slug,))
        self.assertRedirects(self.client.get(url), reverse('home'))
        url = '%s?%s' % (reverse(
            'organizations:select-active', args=(self.organization.slug,)),
            urlencode({'next': 'http://google.com'}))
        self.assertRedirects(self.client.get(url), reverse('home'))

        self.organization.organizationuserrelation_set.filter(
            user=self.user).delete()
        self.assertEqual(self.client.get(url).status_code, 404)
Пример #9
0
def multi_object_action_view(request):
    """
    Proxy view called first when using a multi object action, which
    then redirects to the appropiate specialized view
    """

    next = request.POST.get(
        "next", request.GET.get("next", request.META.get("HTTP_REFERER", reverse(settings.LOGIN_REDIRECT_URL)))
    )

    action = request.GET.get("action", None)
    id_list = ",".join([key[3:] for key in request.GET.keys() if key.startswith("pk_")])
    items_property_list = [(key[11:]) for key in request.GET.keys() if key.startswith("properties_")]

    if not action:
        messages.error(request, _("No action selected."))
        return HttpResponseRedirect(request.META.get("HTTP_REFERER", reverse(settings.LOGIN_REDIRECT_URL)))

    if not id_list and not items_property_list:
        messages.error(request, _("Must select at least one item."))
        return HttpResponseRedirect(request.META.get("HTTP_REFERER", reverse(settings.LOGIN_REDIRECT_URL)))

    # Separate redirects to keep backwards compatibility with older
    # functions that don't expect a properties_list parameter
    if items_property_list:
        return HttpResponseRedirect(
            "%s?%s" % (action, urlencode({"items_property_list": dumps(items_property_list), "next": next}))
        )
    else:
        return HttpResponseRedirect("%s?%s" % (action, urlencode({"id_list": id_list, "next": next})))
Пример #10
0
 def _fetch(self, uri, post_args, **url_args):
     # Use Django's urlencode because it is unicode safe
     from django.utils.http import urlencode
     url_args["format"] = "json"
     args = urlencode(url_args)
     url = "http://friendfeed.com" + uri + "?" + args
     headers = {}
     if post_args is not None:
         # If we are POSTing then set the method/content-type (urllib2
         # does this for you but urlfetch does not)
         payload = urlencode(post_args)
         method = urlfetch.POST
         headers["Content-Type"] = "application/x-www-form-urlencoded"
     else:
         payload = None
         method = urlfetch.GET
     if self.auth_nickname and self.auth_key:
         pair = "%s:%s" % (self.auth_nickname, self.auth_key)
         token = base64.b64encode(pair)
         headers["Authorization"] = "Basic %s" % token
     result = urlfetch.fetch(url, payload=payload, method=method,
         headers=headers)
     # urllib2 will raise an Exception when you get any error code but
     # urlfetch does not; raise our own (TODO: make an Exception class)
     if result.status_code != 200:
         raise Exception, result.status_code
     return parse_json(result.content)
Пример #11
0
 def _fetch(self, uri, post_args, **url_args):
     # Use Django's urlencode because it is unicode safe
     from django.utils.http import urlencode
     url_args["format"] = "json"
     APIKEY = getattr(settings, "APIKEY", None)
     if APIKEY:
         url_args["apikey"] = APIKEY
     args = urlencode(url_args)
     url = "http://friendfeed.com" + uri + "?" + args
     headers = {}
     if post_args is not None:
         # If we are POSTing then set the method/content-type (urllib2
         # does this for you but urlfetch does not)
         payload = urlencode(post_args)
         method = urlfetch.POST
         headers["Content-Type"] = "application/x-www-form-urlencoded"
     else:
         payload = None
         method = urlfetch.GET
     if self.auth_nickname and self.auth_key:
         pair = "%s:%s" % (self.auth_nickname, self.auth_key)
         token = base64.b64encode(pair)
         headers["Authorization"] = "Basic %s" % token
     result = urlfetch.fetch(url, payload=payload, method=method,
         headers=headers)
     try:
         data = parse_json(result.content)
     except Exception, e:
         data = {
             "errorCode": str(e),
         }
    def get(self, request, *args, **kwargs):
        if not request.user.is_authenticated():
            configure_uri = u'{}?{}'.format(
                reverse('vsts-extension-configuration'),
                urlencode({
                    'targetId': request.GET['targetId'],
                    'targetName': request.GET['targetName'],
                }),
            )

            redirect_uri = u'{}?{}'.format(
                reverse('sentry-login'),
                urlencode({'next': configure_uri}),
            )

            return self.redirect(redirect_uri)

        if request.user.get_orgs().count() == 1:
            org = request.user.get_orgs()[0]

            pipeline = self.init_pipeline(
                request,
                org,
                request.GET['targetId'],
                request.GET['targetName'],
            )

            return pipeline.current_step()
        else:
            return self.redirect(u'/extensions/vsts/link/?{}'.format(
                urlencode({
                    'targetId': request.GET['targetId'],
                    'targetName': request.GET['targetName'],
                })
            ))
Пример #13
0
def mail_documents(request):
    if request.method == 'POST':
        redirect_to = reverse('mail-success')
        mail_failed_url = reverse('mail-failed')
        subject = request.POST.get('subject')
        message = request.POST.get('message_area')
        documents_pks = request.POST.get('document_pks')
        common_pks = request.POST.get('common_pks')
        if not all([subject, message, documents_pks]):
            return HttpResponseRedirect(
                mail_failed_url + '?%s' % urlencode({'error': 'No se llenaron todos los campos'}))
        documents = Documento.objects.filter(pk__in=documents_pks.split(','))
        commons = []
        if common_pks:
            commons = [(common.common_name, common.common_file.file.read())
                       for common in Comun.objects.filter(pk__in=common_pks.split(','))]
        for document in documents:
            document_name = document.document_name
            recipients = [i.strip() for i in document.consorcista.emails.split('/')]
            mail = EmailMessage(subject, message, settings.EMAIL_HOST_USER, recipients + [settings.EMAIL_HOST_USER])
            mail.attach(filename=document_name, content=document.document_file.file.read())
            for common_name, common_content in commons:
                mail.attach(filename=common_name, content=common_content)
            try:
                mail.send()
            except Exception, e:
                redirect_to = mail_failed_url + '?%s' % urlencode({'error': e.message})
                break
        return HttpResponseRedirect(redirect_to)
Пример #14
0
 def test_urlencode(self):
     # 2-tuples (the norm)
     result = http.urlencode((('a', 1), ('b', 2), ('c', 3)))
     self.assertEqual(result, 'a=1&b=2&c=3')
     # A dictionary
     result = http.urlencode({ 'a': 1, 'b': 2, 'c': 3})
     acceptable_results = [
         # Need to allow all of these as dictionaries have to be treated as
         # unordered
         'a=1&b=2&c=3',
         'a=1&c=3&b=2',
         'b=2&a=1&c=3',
         'b=2&c=3&a=1',
         'c=3&a=1&b=2',
         'c=3&b=2&a=1'
     ]
     self.assertTrue(result in acceptable_results)
     # A MultiValueDict
     result = http.urlencode(MultiValueDict({
         'name': ['Adrian', 'Simon'],
         'position': ['Developer']
     }), doseq=True)
     acceptable_results = [
         # MultiValueDicts are similarly unordered
         'name=Adrian&name=Simon&position=Developer',
         'position=Developer&name=Adrian&name=Simon'
     ]
     self.assertTrue(result in acceptable_results)
Пример #15
0
    def init(self, request, paypal_request, paypal_response):
        """Initialize a PayPalNVP instance from a HttpRequest."""
        if request: # allow request=None
            self.ipaddress = request.META.get('REMOTE_ADDR', '').split(':')[0]
            if hasattr(request, "user") and request.user.is_authenticated():
                self.user = request.user
        if not self.ipaddress:
            self.ipaddress = '0.0.0.0'

        # No storing credit card info.
        query_data = dict(
            (k,v) for k, v in paypal_request.iteritems() if
            k not in self.RESTRICTED_FIELDS)
        self.query = urlencode(query_data)
        self.response = urlencode(paypal_response)

        # Was there a flag on the play?
        ack = paypal_response.get('ACK', False)
        if ack != "Success":
            if ack == "SuccessWithWarning":
                self.flag_info = paypal_response.get('L_LONGMESSAGE0', '')
            else:
                self.set_flag(
                    paypal_response.get('L_LONGMESSAGE0', ''),
                    paypal_response.get('L_ERRORCODE', ''))
Пример #16
0
    def on_not_logged_in(self, request, url, error=None):
        """Called whenever the user is not logged in."""
        if request.is_ajax():
            logger.debug('Request is Ajax, returning HTTP 403.')
            return HttpResponseForbidden()

        try:
            for lookup_view in settings.LOGIN_REDIRECT["redirect"]:
                try:
                    if url == reverse(lookup_view):
                        url = parse_url(settings.LOGIN_REDIRECT)
                except NoReverseMatch:
                    try:
                        resolve(lookup_view)
                        if url == lookup_view:
                            url = parse_url(settings.LOGIN_REDIRECT)
                    except Http404:
                        logger.error('Cannot resolve url %s' % lookup_view)
        except KeyError:
            pass
        except Exception:
            logger.error(
                'Error while redirection on not logged in.', exc_info=True)

        args = {'url': url}

        logger.debug(
            'Request is not Ajax, redirecting to %s?%s'
            % (self.login_url, urlencode(args)))
        return HttpResponseRedirect(
            '%s?%s' % (self.login_url, urlencode(args)))
Пример #17
0
def multi_object_action_view(request):
    """
    Proxy view called first when using a multi object action, which
    then redirects to the appropiate specialized view
    """

    next = request.POST.get('next', request.GET.get('next', request.META.get('HTTP_REFERER', reverse('main:home'))))

    action = request.GET.get('action', None)
    id_list = ','.join([key[3:] for key in request.GET.keys() if key.startswith('pk_')])
    items_property_list = [loads(key[11:]) for key in request.GET.keys() if key.startswith('properties_')]

    if not action:
        messages.error(request, _('No action selected.'))
        return HttpResponseRedirect(request.META.get('HTTP_REFERER', reverse('main:home')))

    if not id_list and not items_property_list:
        messages.error(request, _('Must select at least one item.'))
        return HttpResponseRedirect(request.META.get('HTTP_REFERER', reverse('main:home')))

    # Separate redirects to keep backwards compatibility with older
    # functions that don't expect a properties_list parameter
    if items_property_list:
        return HttpResponseRedirect('%s?%s' % (
            action,
            urlencode({'items_property_list': dumps(items_property_list), 'next': next}))
        )
    else:
        return HttpResponseRedirect('%s?%s' % (
            action,
            urlencode({'id_list': id_list, 'next': next}))
        )
Пример #18
0
    def test_create_accounts(self):
        # check invalid email address
        email = "[email protected]@"
        contact_email = "*****@*****.**"
        response = self.client.post('/accounts/', urlencode({'account_id' : email,'full_name':'fl','contact_email':contact_email,'password':'******','primary_secret_p':'primaryp','secondary_secret_p':'secondaryp'}),'application/x-www-form-urlencoded')
        self.assertEquals(response.status_code, 400)
        
        # check invalid contact email address 
        email = "*****@*****.**"
        contact_email = "mybadmail2"
        response = self.client.post('/accounts/', urlencode({'account_id' : email,'full_name':'fl','contact_email':contact_email,'password':'******','primary_secret_p':'primaryp','secondary_secret_p':'secondaryp'}),'application/x-www-form-urlencoded')
        self.assertEquals(response.status_code, 400)
        
        # valid email and contact addresses
        # Make sure DEMO_MODE = False works as expected
        prev_num_accounts = Account.objects.all().count()
        demo_mode = settings.DEMO_MODE
        settings.DEMO_MODE = False
        contact_email = "*****@*****.**"

        # create an Account, normally: should be no records
        response = self.client.post('/accounts/', urlencode({'account_id' : email,'full_name':'fl','contact_email':contact_email,'password':'******','primary_secret_p':'primaryp','secondary_secret_p':'secondaryp'}),'application/x-www-form-urlencoded')
        self.assertEquals(response.status_code, 200)        
        self.assertEqual(Account.objects.all().count(), prev_num_accounts+1)
        new_acct = Account.objects.get(email=email)
        self.assertEqual(list(new_acct.records_owned_by.all()), [])

        settings.DEMO_MODE = demo_mode
Пример #19
0
    def to_link(self, request, instance, urlpattern, kwargs=None,
                query_kwargs=None):
        """Return an absolute url for the given urlpattern."""
        if query_kwargs:
            query_kwargs = {k: getattr(instance, v) for k, v in query_kwargs.items()}
        if not kwargs:
            url = reverse(urlpattern, request=request)
            if not query_kwargs:
                return {'href': url}
            return {'href': '%s?%s' % (url, urlencode(query_kwargs))}

        if isinstance(kwargs, basestring):
            # `(ref, urlpattern, string)` where `string` is equivalent to
            # `{string: string}`
            url = reverse(urlpattern,
                          kwargs={kwargs: getattr(instance, kwargs)},
                          request=request)
            if not query_kwargs:
                return {'href': url}
            return {'href': '%s?%s' % (url, urlencode(query_kwargs))}

        reverse_kwargs = {}
        if kwargs:
            for k, v in kwargs.items():
                reverse_kwargs[k] = getattr(instance, v)
        try:
            url = reverse(urlpattern, kwargs=reverse_kwargs, request=request)
            if not query_kwargs:
                return {'href': url}
            return {'href': '%s?%s' % (url, urlencode(query_kwargs))}
        except NoReverseMatch:
            return None
Пример #20
0
def make_paypal_url(request, payment):

    signer = Signer()
    item_number = signer.sign(unicode(payment.id))

    params = {"cmd": "_xclick",
              "business": settings.ARTSHOW_PAYPAL_ACCOUNT,
              "undefined_quantity": "0",
              "item_name": "Art Show Payment from " + payment.artist.artistname(),
              "item_number": item_number,
              "amount": unicode(payment.amount),
              "shipping": "0",
              "no_shipping": "1",
              "return": request.build_absolute_uri(reverse("artshow.manage.payment_made_paypal",
                                                           args=(payment.artist_id,))),
              "cancel_return": request.build_absolute_uri(
                  reverse("artshow.manage.payment_cancelled_paypal",
                          args=(payment.artist_id,)) + "?" + urlencode({"item_number": item_number})),
              "currency_code": "USD",
              "bn": "PP-BuyNow",
              "charset": "UTF-8",
              "notify_url": request.build_absolute_uri(reverse(ipn_handler)),
              }

    return settings.ARTSHOW_PAYPAL_URL + "?" + urlencode(params)
Пример #21
0
    def connect(self, handler, **query):
        url = urljoin(API_URL, handler)
        # removes queries with empty values
        query = self.filter_querydict(query)
        is_empty_query = not bool(query)  # save for later reference

        if query:
            url += "?"
            for k, v in query.copy().items():
                # handle OR-ing of search parameters
                if "|" in k:
                    del query[k]
                    url += "|".join(urlencode({i: v}) for i in k.split("|"))
        if query:
            url += "&" + urlencode(query).replace("%7C", "|")

        if handler == "activity" and is_empty_query:
            # Handles caching for the main search page
            cached_data = cache.get("all-activities")
            remote_last_updated = unicode(self.html_or_404(urljoin(API_URL, "last_updated/")))
            cache_invalid = cache.get("last_updated") != remote_last_updated

            if cached_data and not cache_invalid:
                # Cache hit!
                json = cached_data
            else:
                # No cache! Get data and fill cache
                json = self.json_or_404(url)
                cache.set("all-activities", json, 60 * 60 * 24)
                cache.set("last_updated", remote_last_updated)
        else:
            json = self.json_or_404(url)
        return json
Пример #22
0
def hardcodedopenid(request, domain):
    parameters = {
        'openid.mode': "checkid_setup",
        'openid.ns': "http://specs.openid.net/auth/2.0",
        'openid.return_to': 'http://%s/login/callback' % request.get_host(),
        #'openid.return_to': 'http://test.escolarea.com/login/callback',                
        'openid.claimed_id': 'http://specs.openid.net/auth/2.0/identifier_select',
        'openid.identity':'http://specs.openid.net/auth/2.0/identifier_select',
        'openid.assoc_handle': CONSUMER_SECRET,
        'openid.realm': 'http://%s' % request.get_host(),
        'openid.ns.ax': "http://openid.net/srv/ax/1.0",
        'openid.ax.mode': "fetch_request",
        'openid.ax.required': "firstname,lastname,email",
        'openid.ax.type.email': "http://axschema.org/contact/email",
        'openid.ax.type.firstname': "http://axschema.org/namePerson/first",
        'openid.ax.type.lastname': "http://axschema.org/namePerson/last",
        'openid.ns.oauth': 'http://specs.openid.net/extensions/oauth/1.0',
        'openid.oauth.consumer': CONSUMER_KEY,
        'openid.oauth.scope': ' '.join(OAUTH_SCOPE), 
        }

    if domain is 'default':
        url = "https://www.google.com/accounts/o8/ud?%s" % urlencode(parameters)
    else:
        url = "https://www.google.com/a/%s/o8/ud?be=o8&%s" % (domain, urlencode(parameters))

    print url
    return redirect(to=url)
Пример #23
0
def dashboard(request):
    args = [] # params to pass to l10nstats json
    query = [] # params to pass to shipping json
    subtitles = []
    if 'ms' in request.GET:
        mstone = get_object_or_404(Milestone, code=request.GET['ms'])
        args.append(('tree', mstone.appver.tree.code))
        subtitles.append(str(mstone))
        query.append(('ms', mstone.code))
    elif 'av' in request.GET:
        appver = get_object_or_404(AppVersion, code=request.GET['av'])
        args.append(('tree', (appver.tree is not None and appver.tree.code)
                     or appver.lasttree.code))
        subtitles.append(str(appver))
        query.append(('av', appver.code))

    # sanitize the list of locales to those that are actually on the dashboard
    locales = Locale.objects.filter(code__in=request.GET.getlist('locale'))
    locales = locales.values_list('code', flat=True)
    args += [("locale", loc) for loc in locales]
    query += [("locale", loc) for loc in locales]
    subtitles += list(locales)

    return render_to_response('shipping/dashboard.html', {
            'subtitles': subtitles,
            'query': mark_safe(urlencode(query)),
            'args': mark_safe(urlencode(args)),
            }, context_instance=RequestContext(request))
Пример #24
0
 def test_urlencode(self):
     # 2-tuples (the norm)
     result = http.urlencode((("a", 1), ("b", 2), ("c", 3)))
     self.assertEqual(result, "a=1&b=2&c=3")
     # A dictionary
     result = http.urlencode({"a": 1, "b": 2, "c": 3})
     acceptable_results = [
         # Need to allow all of these as dictionaries have to be treated as
         # unordered
         "a=1&b=2&c=3",
         "a=1&c=3&b=2",
         "b=2&a=1&c=3",
         "b=2&c=3&a=1",
         "c=3&a=1&b=2",
         "c=3&b=2&a=1",
     ]
     self.assertTrue(result in acceptable_results)
     # A MultiValueDict
     result = http.urlencode(MultiValueDict({"name": ["Adrian", "Simon"], "position": ["Developer"]}), doseq=True)
     acceptable_results = [
         # MultiValueDicts are similarly unordered
         "name=Adrian&name=Simon&position=Developer",
         "position=Developer&name=Adrian&name=Simon",
     ]
     self.assertTrue(result in acceptable_results)
Пример #25
0
 def test_permission_resource_detail(self):
     """Test access permission to resource details (JSON & CSV)
     """
     for i in [
             models.VegetationVisit, models.StratumSpecies,
             models.TransectDistinctChanges, models.BasalBitterlichObservation,
             models.ErosionPeg, models.PegObservation, models.StratumSummary,
             models.DisturbanceIndicator, models.PlantObservation,
             models.BiodiversityIndicator]:
         self.client.logout()
         obj = i.objects.all()[0]
         url = reverse('api_dispatch_detail', kwargs={
             'resource_name': i._meta.object_name.lower(),
             'api_name': 'v1',
             'pk': obj.pk})
         url_json = url + '?' + urlencode({'format': 'json'})
         url_csv = url + '?' + urlencode({'format': 'csv'})
         response = self.client.get(url_json)  # Anonymous user
         self.assertEqual(response.status_code, 401)
         # Authorised users
         for user in ['custodian', 'uploader']:
             self.client.login(username=user, password='******')
             response = self.client.get(url_json)
             self.assertEqual(response.status_code, 200)
             response = self.client.get(url_csv)
             self.assertEqual(response.status_code, 200)
Пример #26
0
def rpx_response(request):
    '''
    Handles the POST response from RPX API. This is where the user is sent
    after signing in through RPX.

    @param request: Django request object.
    @return: Redirect that takes user to 'next' or LOGIN_REDIRECT_URL.
    '''
    #According to http://rpxwiki.com/Passing-state-through-RPX, the query
    #string parameters in our token url will be POST to our rpx_response so
    #that we can retain some state information. We use this for 'next', a
    #var that specifies where the user should be redirected after successful
    #login.
    destination = request.POST.get('next', settings.LOGIN_REDIRECT_URL)
            
    if request.method == 'POST':
        #RPX also sends token back via POST. We pass this token to our RPX auth
        #backend which, then, uses the token to access the RPX API to confirm 
        #that the user logged in successfully and to obtain the user's login
        #information.
        token = request.POST.get('token', False)
        if token: 
            response = auth.authenticate(token = token)
            #The django_rpx_plus auth backend can return three things: None (means
            #that auth has failed), a RpxData object (means that user has passed
            #auth but is not registered), or a User object (means that user is
            #auth AND registered).
            
            if type(response) == User:
                #Successful auth and user is registered so we login user.
                auth.login(request, response)
                return redirect(destination)
            elif type(response) == RpxData:
                #Successful auth, but user is NOT registered! So we redirect
                #user to the register page. However, in order to tell the
                #register view that the user is authed but not registered, 
                #we set a session var that points to the RpxData object 
                #primary ID. After the user has been registered, this session
                #var will be removed.
                request.session[RPX_ID_SESSION_KEY] = response.id
                #For security purposes, there could be a case where user 
                #decides not to register but then never logs out either. 
                #Another person can come along and then use the REGISTER_URL
                #to continue creating the account. So we expire this session
                #after a set time interval. (Note that this session expiry
                #setting will be cleared when user completes registration.)
                request.session.set_expiry(60 * 10) #10 min

                query_params = urlencode({'next': destination})
                return redirect(settings.REGISTER_URL+'?'+query_params)
            else:
                #Do nothing, auth has failed.
                pass

    #Authentication has failed. We'll send user  back to login page where error
    #message is displayed.
    messages.error(request, 'There was an error in signing you in. Try again?')
    query_params = urlencode({'next': destination})
    return redirect(reverse('auth_login')+'?'+query_params)
Пример #27
0
 def test_limit_offset_filter(self):
     filter_url = self.url + '?' + urlencode({'map': self.obj.map.id, 'limit': 1, 'offset': 0})
     response = self.client.get(filter_url)
     self.assertEqual(response.status_code, status.HTTP_200_OK)
     self.assertIn(self.data, response.data['results'])
     filter_url = self.url + '?' + urlencode({'map': self.obj.map.id, 'limit': 1, 'offset': 1})
     response = self.client.get(filter_url)
     self.assertNotIn(self.data, response.data['results'])
Пример #28
0
    def test_url(self):
        eq_(self.s.deserialize(urlencode({'foo': 'bar'}),
                               'application/x-www-form-urlencoded'),
            {'foo': 'bar'})

        eq_(self.s.deserialize(urlencode({'foo': u'baré'}),
                               'application/x-www-form-urlencoded'),
            {'foo': u'baré'})
Пример #29
0
def passthrough_next_redirect_url(request, url, redirect_field_name):
    next_url = get_next_redirect_url(request, redirect_field_name)
    if next_url:
        if url.find("?") == -1:
            url = url + "?" + urlencode({redirect_field_name: next_url})
        else:
            url = url + "&" + urlencode({redirect_field_name: next_url})
    return url
Пример #30
0
def metadata_add(request, document_id=None, document_id_list=None):
    check_permissions(request.user, [PERMISSION_METADATA_DOCUMENT_ADD])

    if document_id:
        documents = [get_object_or_404(Document, pk=document_id)]
    elif document_id_list:
        documents = [get_object_or_404(Document, pk=document_id) for document_id in document_id_list.split(',')]
    else:
        messages.error(request, _(u'Must provide at least one document.'))
        return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))

    for document in documents:
        RecentDocument.objects.add_document_for_user(request.user, document)

    post_action_redirect = reverse('document_list_recent')

    next = request.POST.get('next', request.GET.get('next', request.META.get('HTTP_REFERER', post_action_redirect)))

    if request.method == 'POST':
        form = AddMetadataForm(request.POST)
        if form.is_valid():
            metadata_type = form.cleaned_data['metadata_type']
            for document in documents:
                document_metadata, created = DocumentMetadata.objects.get_or_create(document=document, metadata_type=metadata_type, defaults={'value': u''})
                if created:
                    messages.success(request, _(u'Metadata type: %(metadata_type)s successfully added to document %(document)s.') % {
                        'metadata_type': metadata_type, 'document': document})
                else:
                    messages.warning(request, _(u'Metadata type: %(metadata_type)s already present in document %(document)s.') % {
                        'metadata_type': metadata_type, 'document': document})

            if len(documents) == 1:
                return HttpResponseRedirect(u'%s?%s' % (
                    reverse(metadata_edit, args=[document.pk]),
                    urlencode({'next': next}))
                )
            elif len(documents) > 1:
                return HttpResponseRedirect(u'%s?%s' % (
                    reverse('metadata_multiple_edit'),
                    urlencode({'id_list': document_id_list, 'next': next}))
                )

    else:
        form = AddMetadataForm()

    context = {
        #'form_display_mode_table': True,
        'form': form,
        'next': next,
    }
    if len(documents) == 1:
        context['object'] = documents[0]
        context['title'] = _(u'Add metadata type to document: %s') % ', '.join([unicode(d) for d in documents])
    elif len(documents) > 1:
        context['title'] = _(u'Add metadata type to documents: %s') % ', '.join([unicode(d) for d in documents])

    return render_to_response('generic_form.html', context,
        context_instance=RequestContext(request))
Пример #31
0
 def get_chart_url(self, name, v):
     return self.model_admin_url('chart', name) + "?" + urlencode(
         self.list_params)
Пример #32
0
 def _build_url(self, *args, **kwargs):
     get = kwargs.pop("get", {})
     url = reverse(*args, **kwargs)
     if get:
         url += "?" + urlencode(get)
     return url
Пример #33
0
def get_aid_url(url, aid_code):
    return '?'.join([url, urlencode({app_settings.PARAM_NAME: aid_code})])
Пример #34
0
def replace(text, max_width=MAX_WIDTH, max_height=MAX_HEIGHT):
    """
    Scans a block of text, replacing anything matched by a ``ProviderRule``
    pattern with an OEmbed html snippet, if possible.
    
    Templates should be stored at oembed/{format}.html, so for example:
        
        oembed/video.html
        
    These templates are passed a context variable, ``response``, which is a 
    dictionary representation of the response.
    """
    rules = list(ProviderRule.objects.all())
    patterns = [re.compile(r'[\'"=]?' + r.regex)
                for r in rules]  # Compiled patterns from the rules
    parts = []  # The parts that we will assemble into the final return value.
    indices = [
    ]  # List of indices of parts that need to be replaced with OEmbed stuff.
    indices_rules = [
    ]  # List of indices into the rules in order for which index was gotten by.
    urls = set()  # A set of URLs to try to lookup from the database.
    stored = {}  # A mapping of URLs to StoredOEmbed objects.
    index = 0
    # First we pass through the text, populating our data structures.
    for i, part in re_parts(patterns, text):
        # if it starts with a quote or equals sign we're going to assume it's
        # inside an html tag attribute which means it doesn't need to get
        # re-embedded
        if i == -1 or part[0] in ('"', "'", "="):
            parts.append(part)
            index += 1
        else:
            to_append = ""
            # If the link ends with one of our overrides, build a list
            while part[-1] in END_OVERRIDES:
                to_append += part[-1]
                part = part[:-1]
            indices.append(index)
            urls.add(part)
            indices_rules.append(i)
            parts.append(part)
            index += 1
            if to_append:
                parts.append(to_append)
                index += 1

    # Now we fetch a list of all stored patterns, and put it in a dictionary
    # mapping the URL to to the stored model instance.
    for stored_embed in StoredOEmbed.objects.filter(match__in=urls,
                                                    max_width=max_width,
                                                    max_height=max_height):
        stored[stored_embed.match] = stored_embed

    # Now we're going to do the actual replacement of URL to embed.
    for i, id_to_replace in enumerate(indices):
        rule = rules[indices_rules[i]]
        part = parts[id_to_replace]
        try:
            # Try to grab the stored model instance from our dictionary, and
            # use the stored HTML fragment as a replacement.
            parts[id_to_replace] = stored[part].html
        except KeyError:
            try:
                # Build the URL based on the properties defined in the OEmbed spec.
                sep = "?" in rule.endpoint and "&" or "?"
                q = urlencode({
                    "url": part,
                    "maxwidth": max_width,
                    "maxheight": max_height,
                    "format": FORMAT
                })
                url = u"%s%s%s" % (rule.endpoint, sep, q)
                # Fetch the link and parse the JSON.
                resp = simplejson.loads(fetch(url))
                # Depending on the embed type, grab the associated template and
                # pass it the parsed JSON response as context.
                replacement = render_to_string('oembed/%s.html' % resp['type'],
                                               {'response': resp})
                if replacement:
                    stored_embed = StoredOEmbed.objects.create(
                        match=part,
                        max_width=max_width,
                        max_height=max_height,
                        html=replacement,
                    )
                    stored[stored_embed.match] = stored_embed
                    parts[id_to_replace] = replacement
                else:
                    raise ValueError
            except ValueError:
                parts[id_to_replace] = part
            except KeyError:
                parts[id_to_replace] = part
            except urllib2.HTTPError:
                parts[id_to_replace] = part

    # Combine the list into one string and return it.
    return mark_safe(u''.join(parts))
Пример #35
0
 def _get_editable_context(self,
                           context,
                           instance,
                           language,
                           edit_fields,
                           view_method,
                           view_url,
                           querystring,
                           editmode=True):
     """
     Populate the contex with the requested attributes to trigger the changeform
     """
     request = context['request']
     if hasattr(request, 'toolbar'):
         lang = request.toolbar.toolbar_language
     else:
         lang = get_language()
     with force_language(lang):
         extra_context = {}
         if edit_fields == 'changelist':
             instance.get_plugin_name = u"%s %s list" % (smart_text(
                 _('Edit')), smart_text(instance._meta.verbose_name))
             extra_context['attribute_name'] = 'changelist'
         elif editmode:
             instance.get_plugin_name = u"%s %s" % (smart_text(
                 _('Edit')), smart_text(instance._meta.verbose_name))
             if not context.get('attribute_name', None):
                 # Make sure CMS.Plugin object will not clash in the frontend.
                 extra_context['attribute_name'] = '-'.join(edit_fields) \
                                                     if not isinstance('edit_fields', six.string_types) else edit_fields
         else:
             instance.get_plugin_name = u"%s %s" % (smart_text(
                 _('Add')), smart_text(instance._meta.verbose_name))
             extra_context['attribute_name'] = 'add'
         extra_context['instance'] = instance
         extra_context['generic'] = instance._meta
         # view_method has the precedence and we retrieve the corresponding
         # attribute in the instance class.
         # If view_method refers to a method it will be called passing the
         # request; if it's an attribute, it's stored for later use
         if view_method:
             method = getattr(instance, view_method)
             if callable(method):
                 url_base = method(context['request'])
             else:
                 url_base = method
         else:
             # The default view_url is the default admin changeform for the
             # current instance
             if not editmode:
                 view_url = 'admin:%s_%s_add' % (instance._meta.app_label,
                                                 instance._meta.module_name)
                 url_base = reverse(view_url)
             elif not edit_fields:
                 if not view_url:
                     view_url = 'admin:%s_%s_change' % (
                         instance._meta.app_label,
                         instance._meta.module_name)
                 if isinstance(instance, Page):
                     url_base = reverse(view_url,
                                        args=(instance.pk, language))
                 else:
                     url_base = reverse(view_url, args=(instance.pk, ))
             else:
                 if not view_url:
                     view_url = 'admin:%s_%s_edit_field' % (
                         instance._meta.app_label,
                         instance._meta.module_name)
                 if view_url.endswith('_changelist'):
                     url_base = reverse(view_url)
                 else:
                     url_base = reverse(view_url,
                                        args=(instance.pk, language))
                 querystring['edit_fields'] = ",".join(
                     context['edit_fields'])
         if editmode:
             extra_context['edit_url'] = "%s?%s" % (url_base,
                                                    urlencode(querystring))
         else:
             extra_context['edit_url'] = "%s" % url_base
         extra_context['refresh_page'] = True
         # We may be outside the CMS (e.g.: an application which is not attached via Apphook)
         # in this case we may only go back to the home page
         if getattr(context['request'], 'current_page', None):
             extra_context['redirect_on_close'] = context[
                 'request'].current_page.get_absolute_url(language)
         else:
             extra_context['redirect_on_close'] = ''
     return extra_context
Пример #36
0
 def get_link_url(self, datum):
     base_url = reverse(self.url)
     params = urlencode({"snapshot_id": self.table.get_object_id(datum)})
     return "?".join([base_url, params])
Пример #37
0
 def test_environ(self):
     f = self.urlopen('/environ_view/?%s' % urlencode({'q': 'тест'}))
     self.assertIn(b"QUERY_STRING: 'q=%D1%82%D0%B5%D1%81%D1%82'", f.read())
Пример #38
0
 def replace_query_params(self, url, params):
     (scheme, netloc, path, query, fragment) = urlparse.urlsplit(url)
     query_dict = QueryDict(query).dict()
     query_dict.update(params)
     query = urlencode(query_dict)
     return urlparse.urlunsplit((scheme, netloc, path, query, fragment))
Пример #39
0
def make_twitter_url(page_url, message):
    url = "https://twitter.com/share/?%s"
    url_param = urlencode({'text': message, 'url': page_url})
    return url % url_param
Пример #40
0
 def get_link_url(self, domain):
     step = 'update_group_members'
     base_url = reverse(self.url, args=[domain.id])
     param = urlencode({"step": step})
     return "?".join([base_url, param])
Пример #41
0
def show_dictionary(request, project, lang):
    prj = get_project(request, project)
    lang = get_object_or_404(Language, code=lang)

    if request.method == 'POST' and request.user.has_perm('glossary.add', prj):
        form = WordForm(request.POST)
        if form.is_valid():
            Dictionary.objects.create(request.user,
                                      project=prj,
                                      language=lang,
                                      source=form.cleaned_data['source'],
                                      target=form.cleaned_data['target'])
        return redirect_next(request.POST.get('next'), request.get_full_path())
    form = WordForm()

    uploadform = DictUploadForm()

    words = Dictionary.objects.filter(project=prj,
                                      language=lang).order_by(Lower('source'))

    letterform = LetterForm(request.GET)

    searchform = OneWordForm(request.GET)

    if searchform.is_valid() and searchform.cleaned_data['term'] != '':
        words = words.filter(source__icontains=searchform.cleaned_data['term'])
        search = searchform.cleaned_data['term']
    else:
        search = ''

    if letterform.is_valid() and letterform.cleaned_data['letter'] != '':
        words = words.filter(
            source__istartswith=letterform.cleaned_data['letter'])
        letter = letterform.cleaned_data['letter']
    else:
        letter = ''

    words = get_paginator(request, words)

    last_changes = Change.objects.last_changes(request.user).filter(
        dictionary__project=prj, dictionary__language=lang)[:10]

    return render(
        request, 'dictionary.html', {
            'title':
            dict_title(prj, lang),
            'project':
            prj,
            'language':
            lang,
            'page_obj':
            words,
            'form':
            form,
            'query_string':
            urlencode({
                'term': search,
                'letter': letter
            }),
            'uploadform':
            uploadform,
            'letterform':
            letterform,
            'searchform':
            searchform,
            'letter':
            letter,
            'last_changes':
            last_changes,
            'last_changes_url':
            urlencode({
                'project': prj.slug,
                'lang': lang.code,
                'glossary': 1
            }),
        })
Пример #42
0
def make_facebook_url(page_url, msg):
    title = u'%s: %s' % (msg, page_url)
    url = "https://www.facebook.com/sharer.php?%s"
    url_param = urlencode({'u': page_url, 't': title})
    return url % url_param
 def get_context_data(self, *, object_list=None, **kwargs):
     context = super().get_context_data(object_list=object_list, **kwargs)
     context['form'] = self.form
     if self.search_value:
         context['query'] = urlencode({'search': self.search_value})
     return context
Пример #44
0
    def get_context_data(self, **kwargs):
        """Create context for rendering page."""
        context = super().get_context_data(**kwargs)
        context["project"] = self.project

        url = {}

        if self.translation is not None:
            context["project"] = self.translation.component.project
            context["component"] = self.translation.component
            context["translation"] = self.translation
            url["lang"] = self.translation.language.code
            url["component"] = self.translation.component.slug
            url["project"] = self.translation.component.project.slug
            context["changes_rss"] = reverse("rss-translation", kwargs=url)
            context["title"] = (
                pgettext("Changes in translation", "Changes in %s") %
                self.translation)
        elif self.component is not None:
            context["project"] = self.component.project
            context["component"] = self.component
            url["component"] = self.component.slug
            url["project"] = self.component.project.slug
            context["changes_rss"] = reverse("rss-component", kwargs=url)
            context["title"] = (
                pgettext("Changes in component", "Changes in %s") %
                self.component)
        elif self.project is not None:
            context["project"] = self.project
            url["project"] = self.project.slug
            context["changes_rss"] = reverse("rss-project", kwargs=url)
            context["title"] = (
                pgettext("Changes in project", "Changes in %s") % self.project)

        if self.language is not None:
            context["language"] = self.language
            url["lang"] = self.language.code
            if "changes_rss" not in context:
                context["changes_rss"] = reverse("rss-language", kwargs=url)
            if "title" not in context:
                context["title"] = (
                    pgettext("Changes in language", "Changes in %s") %
                    self.language)

        if self.user is not None:
            context["changes_user"] = self.user
            url["user"] = self.user.username
            if "title" not in context:
                context["title"] = (
                    pgettext("Changes by user", "Changes by %s") %
                    self.user.full_name)

        url = list(url.items())
        for action in self.actions:
            url.append(("action", action))

        if self.start_date:
            url.append(("start_date", self.start_date.date()))

        if self.end_date:
            url.append(("end_date", self.end_date.date()))

        if not url:
            context["changes_rss"] = reverse("rss")

        context["query_string"] = urlencode(url)

        context["form"] = ChangesForm(self.request, data=self.request.GET)

        context["search_items"] = url

        return context
Пример #45
0
 def add_context(self):
     return dict( page=urlencode(self.request.GET.items()) )
    def __call__(self, request, context=None):
        self.request = request

        self.form = self.build_form()
        if 'search_object' in request.GET:
            if request.GET['search_object'] != "all":
                self.form.selected_facets = [u'facet_model_name_exact:%s' % \
                                              request.GET['search_object']]
        self.query = self.get_query().strip('\\')
        #TODO List of fields should be gathered
        # automatically from our SearchIndex classes
        fields = ['content', 'name', 'title']
        sq, not_sq = parse_query_into_sq(self.query, fields)
        if sq:
            self.form.searchqueryset = self.form.searchqueryset.filter(sq)
        if not_sq:
            self.form.searchqueryset = self.form.searchqueryset.exclude(not_sq)

        self.results = self.get_results()
        if 'sort' in request.GET:
            self.sort = request.GET['sort']
        else:
            self.sort = ''
        if self.sort == 'country':
            self.results = self.results.order_by('country', '-_score')
        elif self.sort == 'year':
            self.results = self.results.order_by('year', '-_score')
        elif len(self.form.selected_facets) == 1:
            if self.sort:
                if self.form.selected_facets[0] in \
                  [u'facet_model_name_exact:publisher',
                   u'facet_model_name_exact:indicia publisher',
                   u'facet_model_name_exact:brand group',
                   u'facet_model_name_exact:brand emblem',
                   u'facet_model_name_exact:series']:
                    if request.GET['sort'] == 'alpha':
                        self.results = self.results.order_by(
                            'sort_name', 'year')
                    elif request.GET['sort'] == 'chrono':
                        self.results = self.results.order_by(
                            'year', 'sort_name')
                elif u'facet_model_name_exact:issue' in self.form.selected_facets:
                    if request.GET['sort'] == 'alpha':
                        self.results = self.results.order_by(
                            'sort_name', 'key_date', 'sort_code')
                    elif request.GET['sort'] == 'chrono':
                        self.results = self.results.order_by(
                            'key_date', 'sort_name', 'sort_code')
                elif u'facet_model_name_exact:story' in self.form.selected_facets:
                    if request.GET['sort'] == 'alpha':
                        self.results = self.results.order_by(
                            'sort_name', 'key_date', 'sort_code',
                            'sequence_number')
                    elif request.GET['sort'] == 'chrono':
                        self.results = self.results.order_by(
                            'key_date', 'sort_name', 'sort_code',
                            'sequence_number')
        if self.query:
            self.query = urlencode({'q': self.query.encode('utf-8')})
        self.paginator = ResponsePaginator(self.results,
                                           view=self.create_response,
                                           vars=context)
        return self.paginator.paginate(request)
Пример #47
0
    if not style in ('drag', 'button'):
        raise TemplateSyntaxError('style argument must be set to \'drag\' or \'button\'')

    container_id = 'bambu_fileupload_%s' % ''.join(random.sample(string.digits + string.letters, 6))
    script = """\n<script>\n//<![CDATA[\njQuery(document).ready(
        function($) {
            bambu.fileupload.init('%s','%s?%s', %s%s);
            %s
        }
    );\n//]]>\n</script>\n""" % (
        container_id,
        reverse('fileupload'),
        urlencode(
            {
                'handler': handler,
                'params': urlencode(kwargs)
            }
        ),
        callback_js,
        deletable and ", '%s?%s'" % (
            reverse('fileupload_delete'),
            urlencode(
                {
                    'handler': handler,
                    'params': urlencode(kwargs)
                }
            )
        ) or '',
        listable and (
            'bambu.fileupload.list(\'%s\', \'%s?%s\');' % (container_id,
                reverse('fileupload_list'),
Пример #48
0
    def run(cls, database=DEFAULT_DB_ALIAS, **kwargs):
        import frepple

        # Uncomment the following lines to bypass the connection to odoo and use
        # a XML flat file alternative. This can be useful for debugging.
        #with open("my_path/my_data_file.xml", 'rb') as f:
        #  frepple.readXMLdata(f.read().decode('utf-8'), False, False)
        #  frepple.printsize()
        #  return

        odoo_user = Parameter.getValue("odoo.user", database)

        if settings.ODOO_PASSWORDS.get(database) == '':
            odoo_password = Parameter.getValue("odoo.password", database)
        else:
            odoo_password = settings.ODOO_PASSWORDS.get(database)

        odoo_db = Parameter.getValue("odoo.db", database)
        odoo_url = Parameter.getValue("odoo.url", database)
        odoo_company = Parameter.getValue("odoo.company", database)
        ok = True
        if not odoo_user:
            logger.error("Missing or invalid parameter odoo.user")
            ok = False
        if not odoo_password:
            logger.error("Missing or invalid parameter odoo.password")
            ok = False
        if not odoo_db:
            logger.error("Missing or invalid parameter odoo.db")
            ok = False
        if not odoo_url:
            logger.error("Missing or invalid parameter odoo.url")
            ok = False
        if not odoo_company:
            logger.error("Missing or invalid parameter odoo.company")
            ok = False
        odoo_language = Parameter.getValue("odoo.language", database, 'en_US')
        if not ok:
            raise Exception("Odoo connector not configured correctly")

        # Connect to the odoo URL to GET data
        url = "%sfrepple/xml?%s" % (odoo_url,
                                    urlencode({
                                        'database': odoo_db,
                                        'language': odoo_language,
                                        'company': odoo_company,
                                        'mode': cls.mode
                                    }))
        try:
            request = Request(url)
            encoded = base64.encodestring(
                ('%s:%s' % (odoo_user, odoo_password)).encode('utf-8'))[:-1]
            request.add_header("Authorization",
                               "Basic %s" % encoded.decode('ascii'))
        except HTTPError as e:
            logger.error("Error connecting to odoo at %s: %s" % (url, e))
            raise e

        # Download and parse XML data
        with urlopen(request) as f:
            frepple.readXMLdata(f.read().decode('utf-8'), False, False)
        frepple.printsize()
Пример #49
0
 def get_link_url(self, project):
     step = 'update_quotas'
     base_url = reverse(self.url, args=[project.id])
     param = urlencode({"step": step})
     return "?".join([base_url, param])
Пример #50
0
def browse(request, parent_page_id=None):
    # A missing or empty page_type parameter indicates 'all page types'
    # (i.e. descendants of wagtailcore.page)
    page_type_string = request.GET.get("page_type") or "wagtailcore.page"
    user_perm = request.GET.get("user_perms", False)

    try:
        desired_classes = page_models_from_string(page_type_string)
    except (ValueError, LookupError):
        raise Http404

    # Find parent page
    if parent_page_id:
        parent_page = get_object_or_404(Page, id=parent_page_id)
    elif desired_classes == (Page, ):
        # Just use the root page
        parent_page = Page.get_first_root_node()
    else:
        # Find the highest common ancestor for the specific classes passed in
        # In many cases, such as selecting an EventPage under an EventIndex,
        # this will help the administrator find their page quicker.
        all_desired_pages = Page.objects.all().type(*desired_classes)
        parent_page = all_desired_pages.first_common_ancestor()

    parent_page = parent_page.specific

    # Get children of parent page (without streamfields)
    pages = parent_page.get_children().defer_streamfields().specific()

    # allow hooks to modify the queryset
    for hook in hooks.get_hooks("construct_page_chooser_queryset"):
        pages = hook(pages, request)

    # Filter them by page type
    if desired_classes != (Page, ):
        # restrict the page listing to just those pages that:
        # - are of the given content type (taking into account class inheritance)
        # - or can be navigated into (i.e. have children)
        choosable_pages = pages.type(*desired_classes)
        descendable_pages = pages.filter(numchild__gt=0)
        pages = choosable_pages | descendable_pages

    can_choose_root = request.GET.get("can_choose_root", False)
    target_pages = Page.objects.filter(pk__in=[
        int(pk) for pk in request.GET.get("target_pages", "").split(",") if pk
    ])

    match_subclass = request.GET.get("match_subclass", True)

    # Do permission lookups for this user now, instead of for every page.
    permission_proxy = UserPagePermissionsProxy(request.user)

    # Parent page can be chosen if it is a instance of desired_classes
    parent_page.can_choose = can_choose_page(
        parent_page,
        permission_proxy,
        desired_classes,
        can_choose_root,
        user_perm,
        target_pages=target_pages,
        match_subclass=match_subclass,
    )

    selected_locale = None
    locale_options = []
    show_locale_labels = getattr(settings, "WAGTAIL_I18N_ENABLED", False)
    if show_locale_labels:
        pages = pages.select_related("locale")

        if parent_page_id is None:
            # 'locale' is the current value of the "Locale" selector in the UI
            if request.GET.get("locale"):
                selected_locale = get_object_or_404(
                    Locale, language_code=request.GET["locale"])
                active_locale_id = selected_locale.pk
            else:
                active_locale_id = Locale.get_active().pk

            # we are at the Root level, so get the locales from the current pages
            choose_url = reverse("wagtailadmin_choose_page")
            locale_options = [{
                "locale":
                locale,
                "url":
                choose_url + "?" + urlencode({
                    "page_type": page_type_string,
                    "locale": locale.language_code
                }),
            } for locale in Locale.objects.filter(
                pk__in=pages.values_list("locale_id")).exclude(
                    pk=active_locale_id)]
        else:
            # We have a parent page (that is not the root page). Use its locale as the selected localer
            selected_locale = parent_page.locale
            # and get the locales based on its available translations
            locales_and_parent_pages = {
                item["locale"]: item["pk"]
                for item in Page.objects.translation_of(parent_page).values(
                    "locale", "pk")
            }
            locales_and_parent_pages[selected_locale.pk] = parent_page.pk
            for locale in Locale.objects.filter(
                    pk__in=list(locales_and_parent_pages.keys())).exclude(
                        pk=selected_locale.pk):
                choose_child_url = reverse(
                    "wagtailadmin_choose_page_child",
                    args=[locales_and_parent_pages[locale.pk]],
                )

                locale_options.append({
                    "locale":
                    locale,
                    "url":
                    choose_child_url + "?" +
                    urlencode({"page_type": page_type_string}),
                })

        # finally, filter the browseable pages on the selected locale
        if selected_locale:
            pages = pages.filter(locale=selected_locale)

    # Pagination
    # We apply pagination first so we don't need to walk the entire list
    # in the block below
    paginator = Paginator(pages, per_page=25)
    pages = paginator.get_page(request.GET.get("p"))

    # Annotate each page with can_choose/can_decend flags
    for page in pages:
        page.can_choose = can_choose_page(
            page,
            permission_proxy,
            desired_classes,
            can_choose_root,
            user_perm,
            target_pages=target_pages,
            match_subclass=match_subclass,
        )
        page.can_descend = page.get_children_count()

    # Render
    context = shared_context(
        request,
        {
            "parent_page":
            parent_page,
            "parent_page_id":
            parent_page.pk,
            "pages":
            pages,
            "search_form":
            SearchForm(),
            "page_type_string":
            page_type_string,
            "page_type_names": [
                desired_class.get_verbose_name()
                for desired_class in desired_classes
            ],
            "page_types_restricted": (page_type_string != "wagtailcore.page"),
            "show_locale_labels":
            show_locale_labels,
            "locale_options":
            locale_options,
            "selected_locale":
            selected_locale,
        },
    )

    return render_modal_workflow(
        request,
        "wagtailadmin/chooser/browse.html",
        None,
        context,
        json_data={
            "step": "browse",
            "parent_page_id": context["parent_page_id"]
        },
    )
Пример #51
0
def urlReplace(context, **kwargs):
    query = context['request'].GET.dict()
    query.update(kwargs)
    return urlencode(query)
Пример #52
0
 def ask_query_string(self):  # TODO: test me
     """returns string to prepopulate title field on the "Add your exercise" page"""
     ask_title = self.stripped_query or self.query or ''
     if not ask_title:
         return ''
     return '?' + urlencode({'title': ask_title})
Пример #53
0
 def query(self, **params):
     url = '%s?%s' % (self.list_endpoint, urlencode(params, doseq=True))
     return self._assert_auth_get_resource(url)
Пример #54
0
def passthrough_next_redirect_url(request, url, redirect_field_name):
    assert url.find("?") < 0  # TODO: Handle this case properly
    next_url = get_next_redirect_url(request, redirect_field_name)
    if next_url:
        url = url + '?' + urlencode({redirect_field_name: next_url})
    return url
Пример #55
0
    def test_forward(self):
        """测试转发回复"""
        scheme = "http"
        netloc = "example.com"
        path = "/debug"
        url = "{scheme}://{netloc}{path}".format(scheme=scheme,
                                                 netloc=netloc,
                                                 path=path)

        token = self.app.token
        timestamp = str(int(time.time()))
        nonce = "123456"
        query_data = dict(timestamp=timestamp, nonce=nonce)
        signer = WeChatSigner()
        signer.add_data(token, timestamp, nonce)
        signature = signer.signature
        query_data["signature"] = signature

        sender = "openid"
        content = "xyz"
        xml = """<xml>
        <ToUserName><![CDATA[toUser]]></ToUserName>
        <FromUserName><![CDATA[{sender}]]></FromUserName>
        <CreateTime>1348831860</CreateTime>
        <MsgType><![CDATA[text]]></MsgType>
        <Content><![CDATA[{content}]]></Content>
        <MsgId>1234567890123456</MsgId>
        </xml>""".format(sender=sender, content=content)
        req_url = url + "?" + urlencode(query_data)
        request = RequestFactory().post(req_url, xml, content_type="text/xml")

        patch_request(request, self.app.name, WeChatMessageInfo)
        message = request.wechat

        reply_text = "abc"

        def reply_test(url, request):
            self.assertEqual(url.scheme, scheme)
            self.assertEqual(url.netloc, netloc)
            self.assertEqual(url.path, path)

            query = dict(parse_qsl(url.query))
            self.assertEqual(query["timestamp"], timestamp)
            self.assertEqual(query["nonce"], nonce)
            self.assertEqual(query["signature"], signature)
            check_signature(self.app.token, query["signature"], timestamp,
                            nonce)

            msg = parse_message(request.body)
            self.assertIsInstance(msg, messages.TextMessage)
            self.assertEqual(msg.source, sender)
            self.assertEqual(msg.content, content)
            reply = replies.create_reply(reply_text, msg)
            return response(content=reply.render())

        handler = self._create_handler(
            replies=dict(type=Reply.MsgType.FORWARD, url=url))

        with common_interceptor(reply_test):
            reply = handler.reply(message)
            self.assertIsInstance(reply, replies.TextReply)
            self.assertEqual(reply.content, reply_text)
            self.assertEqual(reply.target, sender)

        def bad_reply(url, request):
            return response(404)

        with common_interceptor(bad_reply):
            self.assertRaises(HTTPError, lambda: handler.reply(message))
Пример #56
0
    def get_link_url(self, datum):
        base_url = reverse(self.url)

        vol_id = "%s:vol" % self.table.get_object_id(datum)
        params = urlencode({"source_type": "volume_id", "source_id": vol_id})
        return "?".join([base_url, params])
 def test_get_form_passing_auth_url_transport(self):
     """Ensure GETing form over OAuth with correct client credentials in query succeed when DEBUG is True"""
     query = urlencode({'access_token': self.access_token.token})
     response = self.csrf_client.get('/oauth2-test-debug/?%s' % query)
     self.assertEqual(response.status_code, 200)
Пример #58
0
def translate(request, project, component, lang):
    """Generic entry point for translating, suggesting and searching."""
    obj, project, unit_set = parse_params(request, project, component, lang)

    # Search results
    search_result = search(obj, unit_set, request, PositionSearchForm)

    # Handle redirects
    if isinstance(search_result, HttpResponse):
        return search_result

    # Get numer of results
    num_results = len(search_result["ids"])

    # Search offset
    offset = search_result["offset"]

    # Checksum unit access
    checksum_form = ChecksumForm(unit_set, request.GET or request.POST)
    if checksum_form.is_valid():
        unit = checksum_form.cleaned_data["unit"]
        try:
            offset = search_result["ids"].index(unit.id) + 1
        except ValueError:
            messages.warning(request, _("No string matched your search!"))
            return redirect(obj)
    else:
        # Check boundaries
        if not 0 < offset <= num_results:
            messages.info(request, _("The translation has come to an end."))
            # Delete search
            del request.session[search_result["key"]]
            return redirect(obj)

        # Grab actual unit
        try:
            unit = unit_set.get(pk=search_result["ids"][offset - 1])
        except Unit.DoesNotExist:
            # Can happen when using SID for other translation
            messages.error(request, _("Invalid search string!"))
            return redirect(obj)

    # Check locks
    locked = unit.translation.component.locked

    # Some URLs we will most likely use
    base_unit_url = "{0}?{1}&offset=".format(obj.get_translate_url(),
                                             search_result["url"])
    this_unit_url = base_unit_url + str(offset)
    next_unit_url = base_unit_url + str(offset + 1)

    response = None

    # Any form submitted?
    if "skip" in request.POST:
        return redirect(next_unit_url)
    if request.method == "POST":
        if (not locked and "accept" not in request.POST
                and "accept_edit" not in request.POST
                and "delete" not in request.POST and "spam" not in request.POST
                and "upvote" not in request.POST
                and "downvote" not in request.POST):
            # Handle translation
            response = handle_translate(request, unit, this_unit_url,
                                        next_unit_url)
        elif not locked or "delete" in request.POST or "spam" in request.POST:
            # Handle accepting/deleting suggestions
            response = handle_suggestions(request, unit, this_unit_url,
                                          next_unit_url)

    # Handle translation merging
    elif "merge" in request.GET and not locked:
        response = handle_merge(unit, request, next_unit_url)

    # Handle reverting
    elif "revert" in request.GET and not locked:
        response = handle_revert(unit, request, this_unit_url)

    # Pass possible redirect further
    if response is not None:
        return response

    # Show secondary languages for signed in users
    if request.user.is_authenticated:
        secondary = unit.get_secondary_units(request.user)
    else:
        secondary = None

    # Spam protection
    antispam = AntispamForm()

    # Prepare form
    form = TranslationForm(request.user, unit)
    sort = get_sort_name(request)

    return render(
        request,
        "translate.html",
        {
            "this_unit_url":
            this_unit_url,
            "first_unit_url":
            base_unit_url + "1",
            "last_unit_url":
            base_unit_url + str(num_results),
            "next_unit_url":
            next_unit_url,
            "prev_unit_url":
            base_unit_url + str(offset - 1),
            "object":
            obj,
            "project":
            project,
            "unit":
            unit,
            "nearby":
            unit.nearby(request.user.profile.nearby_strings),
            "nearby_keys":
            unit.nearby_keys(request.user.profile.nearby_strings),
            "others":
            get_other_units(unit),
            "search_url":
            search_result["url"],
            "search_items":
            search_result["items"],
            "search_query":
            search_result["query"],
            "offset":
            offset,
            "sort_name":
            sort["name"],
            "sort_query":
            sort["query"],
            "filter_name":
            search_result["name"],
            "filter_count":
            num_results,
            "filter_pos":
            offset,
            "form":
            form,
            "antispam":
            antispam,
            "comment_form":
            CommentForm(
                project,
                initial={
                    "scope":
                    "global" if unit.translation.is_source else "translation"
                },
            ),
            "context_form":
            ContextForm(instance=unit.source_info, user=request.user),
            "search_form":
            search_result["form"].reset_offset(),
            "secondary":
            secondary,
            "locked":
            locked,
            "glossary":
            Term.objects.get_terms(unit),
            "addterm_form":
            TermForm(project),
            "last_changes":
            unit.change_set.prefetch().order()[:10],
            "last_changes_url":
            urlencode(unit.translation.get_reverse_url_kwargs()),
            "display_checks":
            list(get_display_checks(unit)),
            "machinery_services":
            json.dumps(list(MACHINE_TRANSLATION_SERVICES.keys())),
        },
    )
Пример #59
0
def encode_optional(params):
    if params:
        return '?{0}'.format(urlencode(params))
    else:
        return ''
 def test_get_form_failing_auth_url_transport(self):
     """Ensure GETing form over OAuth with correct client credentials in query fails when DEBUG is False"""
     query = urlencode({'access_token': self.access_token.token})
     response = self.csrf_client.get('/oauth2-test/?%s' % query)
     self.assertIn(response.status_code, (status.HTTP_401_UNAUTHORIZED, status.HTTP_403_FORBIDDEN))