Return the full URL that should be redirected to including query parameters.
9535
private String getRedirectUrl(HttpServletRequest request, String newScheme) {
    String serverName = request.getServerName();
    String uri = request.getRequestURI();

    StringBuilder redirect = new StringBuilder(100);
    redirect.append(newScheme);
    redirect.append("://");
    redirect.append(serverName);
    redirect.append(uri);

    String query = request.getQueryString();
    if (query != null) {
      redirect.append('?');
      redirect.append(query);
    }

    return redirect.toString();
  }
1134093
public function getFullUrl(): string
    {
        $queryString = $this->getQueryString();

        return sprintf(
            '%s%s%s',
            static::getBaseUri(),
            $this->getEndpoint(),
            ($queryString) ? '/?'.$queryString : ''
        );
    }
486871
def full_path(self):
        """"""
        return self.path + u'?' + to_unicode(self.query_string, self.url_charset)
975633
def get_url_for_get(url, parameters=None):
        # type: (str, Optional[Dict]) -> str
        
        spliturl = urlsplit(url)
        getparams = OrderedDict(parse_qsl(spliturl.query))
        if parameters is not None:
            getparams.update(parameters)
        spliturl = spliturl._replace(query=urlencode(getparams))
        return urlunsplit(spliturl)
430752
def get_absolute_url(self):
        
        try:
            url = reverse("content-detail-view", kwargs={"pk": self.pk, "slug": self.slug})
        except NoReverseMatch:
            url = None
        return url
1343087
private String getRedirectUrl(RequestParametersHolder requestHolder) throws AlipayApiException {
        StringBuffer urlSb = new StringBuffer(serverUrl);
        try {
            Map<String, String> sortedMap = AlipaySignature.getSortedMap(requestHolder);
            String sortedQuery = WebUtils.buildQuery(sortedMap, charset);
            urlSb.append("?");
            urlSb.append(sortedQuery);
        } catch (IOException e) {
            throw new AlipayApiException(e);
        }

        return urlSb.toString();
    }
975054
def __load(self, redirect=True, preload=False):
        
        query_params = {
            "prop": "info|pageprops",
            "inprop": "url",
            "ppprop": "disambiguation",
            "redirects": "",
        }
        query_params.update(self.__title_query_param())

        request = self.mediawiki.wiki_request(query_params)

        query = request["query"]
        pageid = list(query["pages"].keys())[0]
        page = query["pages"][pageid]

        # determine result of the request
        # missing is present if the page is missing
        if "missing" in page:
            self._raise_page_error()
        # redirects is present in query if page is a redirect
        elif "redirects" in query:
            self._handle_redirect(redirect, preload, query, page)
        # if pageprops is returned, it must be a disambiguation error
        elif "pageprops" in page:
            self._raise_disambiguation_error(page, pageid)
        else:
            self.pageid = pageid
            self.title = page["title"]
            self.url = page["fullurl"]
147023
def geturl(self):
        """"""
        return urlparse.urlunparse((
            self.scheme,
            self.netloc,
            self.path,
            self.params,
            self.query_str,
            self.fragment,
        ))
243314
private function getRedirectUrlFromRequest()
    {
        $request  = $this->application->getRequest();
        $redirect = $request->getQuery('redirect');
        if ($redirect && $this->urlWhitelisted($redirect)) {
            return $redirect;
        }

        $redirect = $request->getPost('redirect');
        if ($redirect && $this->urlWhitelisted($redirect)) {
            return $redirect;
        }

        return false;
    }
785480
def url(self):
        """"""
        if self._url is None:
            self._url = request_uri(self.environ, include_query=1)
        return self._url
230540
def get(self, url, **kwargs):
        
        """

        kwargs.setdefault('allow_redirects', True)
        return self.request('GET', url, **kwargs)
1103488
def make_redirect_url(self, path_info, query_args=None, domain_part=None):
        
        suffix = ""
        if query_args:
            suffix = "?" + self.encode_query_args(query_args)
        return str(
            "%s://%s/%s%s"
            % (
                self.url_scheme or "http",
                self.get_host(domain_part),
                posixpath.join(
                    self.script_name[:-1].lstrip("/"), path_info.lstrip("/")
                ),
                suffix,
            )
        )
390457
def get_done_url(self):
        
        url = self.bundle.get_view_url(self.redirect_to_view,
                                        self.request.user, {}, self.kwargs)
        return self.customized_return_url(url)
1115322
public String url() {

    /* build the fully qualified url with all query parameters */
    StringBuilder url = new StringBuilder(this.path());
    if (!this.queries.isEmpty()) {
      url.append(this.queryLine());
    }
    if (fragment != null) {
      url.append(fragment);
    }

    return url.toString();
  }
517032
def strip_querystring(url):
    """"""
    p = six.moves.urllib.parse.urlparse(url)
    return p.scheme + "://" + p.netloc + p.path
453699
def get_view_url(self):
        
        request = self.request
        url = request.getURL()
        qs = request.getHeader("query_string")
        if not qs:
            return url
        return "{}?{}".format(url, qs)
869870
def get_redirect_url(request):
    

    next_ = request.GET.get(REDIRECT_FIELD_NAME)
    if not next_:
        redirect_url = resolve_url(django_settings.CAS_REDIRECT_URL)
        if django_settings.CAS_IGNORE_REFERER:
            next_ = redirect_url
        else:
            next_ = request.META.get('HTTP_REFERER', redirect_url)
        prefix = urllib_parse.urlunparse(
            (get_protocol(request), request.get_host(), '', '', '', ''),
        )
        if next_.startswith(prefix):
            next_ = next_[len(prefix):]
    return next_