Get request parameters for redirect url.
4605
def get_redirect_args(self, request, callback):
        ""
        callback = force_text(request.build_absolute_uri(callback))
        raw_token = self.get_request_token(request, callback)
        token, secret = self.parse_raw_token(raw_token)
        if token is not None and secret is not None:
            request.session[self.session_key] = raw_token
        return {
            'oauth_token': token,
            'oauth_callback': callback,
        }
208342
protected function determineRedirectURL()
    {
        $this->redirectURL = trim($this->getRoutedParameter('url'));

        if (empty($this->redirectURL))
        {
            $this->setNotReady("Invalid or missing redirect `url` parameter.", null, 404);
        }
    }
151041
def _get_url_params(self, shorten=True):
        """"""
        cable = True if self.category == 'cable' else False
        url_date = convert_month(self.date, shorten=shorten, cable=cable)

        return [
            BASE_URL,
            self.weekday.lower(),
            self.category + '-ratings',
            url_date.replace(' ', '-')
        ]
756536
def get_redirect_url(self, **kwargs):
        ""
        name = kwargs.get('provider', '')
        try:
            provider = Provider.objects.get(name=name)
        except Provider.DoesNotExist:
            raise Http404('Unknown OAuth provider.')
        else:
            if not provider.enabled():
                raise Http404('Provider %s is not enabled.' % name)
            client = self.get_client(provider)
            callback = self.get_callback_url(provider)
            params = self.get_additional_parameters(provider)
            return client.get_redirect_url(self.request, callback=callback, parameters=params)
1046686
private function getRedirects()
    {
        $httpWithJsBackup = [
            $this->httpRedirect,
            $this->jsRedirect
        ];

        return $this->redirect->isTypeJavaScript() ? [$this->jsRedirect] : $httpWithJsBackup;
    }
222329
def get_response(self, request):
        ''''''
        # the redirect key is already placed in the response by HttpResponseJavascriptRedirect
        return HttpResponseJavascriptRedirect(self.redirect_to, *self.args, **self.kwargs)
763136
def getLoginURL(self, redirect_url):
        
        p = Properties()
        p.master = self.master
        clientId = yield p.render(self.clientId)
        oauth_params = {'redirect_uri': self.loginUri,
                        'client_id': clientId, 'response_type': 'code'}
        if redirect_url is not None:
            oauth_params['state'] = urlencode(dict(redirect=redirect_url))
        oauth_params.update(self.authUriAdditionalParams)
        sorted_oauth_params = sorted(oauth_params.items(), key=lambda val: val[0])
        return "%s?%s" % (self.authUri, urlencode(sorted_oauth_params))
1106493
def options(self, url, callback=None, retry=0, **kwargs):
        """"""
        kwargs.setdefault("allow_redirects", True)
        return self.request(
            "options", url=url, callback=callback, retry=retry, **kwargs
        )
516889
def get_encoded_query_params(self):
        """"""
        get_data = encode_items(self.request.GET.lists())
        return urlencode(get_data)
704397
def get_redirect_url(self, *args, **kwargs):
        
        if self.url:
            url = self.url % kwargs
        elif self.pattern_name:
            try:
                url = reverse(self.pattern_name, args=args, kwargs=kwargs)
            except NoReverseMatch:
                return None
        else:
            return None
        return url
789204
def get_redirect_url(self, request):
        
        cp = request.GET.get('cp')
        user = request.user
        Token.objects.filter(user=user).delete()
        token = Token.objects.create(user=user)
        return '{0}?username={1}&token={2}'.format(cp, user.username, token.key)
676948
def get_route_param_names(endpoint):
    """"""
    try:
        g = current_app.url_map.iter_rules(endpoint)
        return next(g).arguments
    except KeyError:
        return {}
361942
public static function URI()
    {
        $REDIRECT_QUERY_STRING =
            isset($_SERVER['QUERY_STRING'])
            ? $_SERVER['QUERY_STRING']
            : '';

        $REDIRECT_URL = '';

        if (isset($_SERVER['REQUEST_URI'])) {
            $url_parts = parse_url($_SERVER['REQUEST_URI']);
            $REDIRECT_URL = $url_parts['path'];
        }

        $URI = rtrim(dirname($_SERVER['SCRIPT_NAME']), '/');

        if (substr($REDIRECT_URL, 0, strlen($URI)) == $URI) {
            $URI = substr($REDIRECT_URL, strlen($URI));
        }

        $URI = urldecode($URI) . '/';

        $URI = trim($URI, '/');

        $parameters = [];

        //Extract parameters from QUERY string
        parse_str($REDIRECT_QUERY_STRING, $parameters);

        return [$URI, $parameters];
    }
1173975
def redirect(self, url):
        """"""
        url = '{}/view'.format(url)
        return self.request.response.redirect(url)
524769
protected function RedirectToCallingPage()
    {
        $aParameters = array();
        $aIncludeParams = TdbShop::GetURLPageStateParameters();
        $oGlobal = TGlobal::instance();
        foreach ($aIncludeParams as $sKeyName) {
            if ($oGlobal->UserDataExists($sKeyName)) {
                $aParameters[$sKeyName] = $oGlobal->GetUserData($sKeyName);
            }
        }
        $sURL = $this->getActivePageService()->getActivePage()->GetRealURLPlain($aParameters);
        $this->getRedirect()->redirect($sURL);
    }
145509
def _get_parameters_from_request(self, request, exception=False):
        """"""
        user = request.user
        referer_url = None
        try:
            referer_dic = urlparse.urlsplit(
                urlparse.unquote(request.META.get('HTTP_REFERER')))
            referer_url = referer_dic[2]
            if referer_dic[3]:
                referer_url += "?" + referer_dic[3]
            if isinstance(referer_url, str):
                referer_url = referer_url.decode('utf-8')
        except Exception:
            pass
        request_url = urlparse.unquote(request.path)
        if request.META['QUERY_STRING']:
            request_url += '?' + request.META['QUERY_STRING']
        return {
            'client_ip': request.META.get('REMOTE_ADDR', None),
            'domain_name': getattr(user, 'domain_name', None),
            'domain_id': getattr(user, 'domain_id', None),
            'project_name': getattr(user, 'project_name', None),
            'project_id': getattr(user, 'project_id', None),
            'user_name': getattr(user, 'username', None),
            'user_id': request.session.get('user_id', None),
            'request_scheme': request.scheme,
            'referer_url': referer_url,
            'request_url': request_url,
            'method': request.method if not exception else None,
            'param': self._get_request_param(request),
        }
71114
def get_authorize_url(self, redirect_uri=None, **kw):
        '''
        
        '''
        redirect = redirect_uri if redirect_uri else self.redirect_uri
        if not redirect:
            raise APIError('21305', 'Parameter absent: redirect_uri', 'OAuth2 request')
        response_type = kw.pop('response_type', 'code')
        return '%s%s?%s' % (self.auth_url, 'authorize',
                            _encode_params(client_id=self.client_id,
                                           response_type=response_type,
                                           redirect_uri=redirect, **kw))