Returns value of next url query parameter if present, default otherwise.
The next query parameter should not contain the domain, the result will.
320870
function(req, params) {
    if(!params) {
      params = URL.parse(req.url, true).query;
    }
    var cconfig = this.config.client;
    var next = params.next || cconfig.default_redirection_url;
    var url = cconfig.base_url + next;
    return url;
  }
120830
def _next_url_info(self) -> URLInfo:
        '''
        '''
        if not self._web_client_session:
            return self._item_session.url_record.url_info

        return self._web_client_session.next_request().url_info
641401
public function getNextPageParams()
    {
        $limit = $this->limit <= 0 ? $this->count : $this->limit;
        $next_url = $this->offset_key
            . $this->offset
            . $this->limit_key
            . $limit;

        if ($this->count <= ($this->offset + $limit)) {
           return false;
        }

        if ($this->count >= $limit) {
            $next_url = $this->offset_key
                . ($this->offset + $limit)
                . $this->limit_key
                . $limit;
        }

        return $next_url;
    }
925361
def append_query_parameter(url, parameters, ignore_if_exists=True):
    
    if ignore_if_exists:
        for key in parameters.keys():
            if key + "=" in url:
                del parameters[key]
    parameters_str = "&".join(k + "=" + v for k, v in parameters.items())
    append_token = "&" if "?" in url else "?"
    return url + append_token + parameters_str
873702
def getquery(self, default=None, encoding='utf-8', errors='strict'):
        
        query = self.query
        if query is None:
            return default
        else:
            return uridecode(query, encoding, errors)
954536
def get_allowed_domain(url, allow_subdomains=True):
        
        if allow_subdomains:
            return re.sub(re_www, '', re.search(r'[^/]+\.[^/]+', url).group(0))
        else:
            return re.search(re_domain, UrlExtractor.get_allowed_domain(url)).group(0)
39470
function(url, key, value) {
    var queryStrPos = url.indexOf('?');
    var anchorStrPos = url.lastIndexOf('#');
    
    var paramSeparator = '&';
    
    if(queryStrPos < 0) {
        // There's no query string.
        paramSeparator = '?';
    }
    
    if (anchorStrPos > 0) {
        // There's an anchor at the end, we need to insert our parameter before it
        var urlBeforeAnchor = url.substring(0, anchorStrPos);
        var urlAnchor = url.substring(anchorStrPos);
        return urlBeforeAnchor + paramSeparator + key + '=' + value + urlAnchor;
    } else {
        return url + paramSeparator + key + '=' + value;
    }
}
481820
def get_redirect_url(self, request, **kwargs):
        
        if self.url:
            url = self.url % kwargs
            args = request.META.get('QUERY_STRING', '')
            if args and self.query_string:
                url = "%s?%s" % (url, args)
            return url
        else:
            return None
1372436
def next_page(self):
        
        if self.page.has_next():
            self.query_dict['page'] = self.page.next_page_number()
            return "%s?%s" % (self.path, urlencode(self.query_dict))
        return ""
841321
def get_domain(url):
    
    parse_result = urlparse(url)
    domain = "{schema}://{netloc}".format(
        schema=parse_result.scheme, netloc=parse_result.netloc)
    return domain
261526
protected String getNextUrl() {
		String url = urls.get(currentIndex);
		currentIndex = (currentIndex + 1) % urls.size();
		return url;
	}
404512
def _next(self, **kwargs):
        
        spec = self._pagination_default_spec(kwargs)
        spec.update(kwargs)

        query = queries.build_query(spec)
        query = queries.where_after_entry(query, self._record)

        for record in query.order_by(model.Entry.local_date,
                                     model.Entry.id)[:1]:
            return Entry(record)
        return None
246827
def _next_page(self):
        
        if self._last_page_seen:
            raise StopIteration
        new, self._last_page_seen = self.conn.query_multiple(self.object_type, self._next_page_index,
                                                             self.url_params, self.query_params)
        self._next_page_index += 1
        if len(new) == 0:
            self._last_page_seen = True  # don't bother with next page if nothing was returned
        else:
            self._results += new
14381
def FqdnUrl(v):
    
    try:
        parsed_url = _url_validation(v)
        if "." not in parsed_url.netloc:
            raise UrlInvalid("must have a domain name in URL")
        return v
    except:
        raise ValueError
507240
def add_next(self, url, context):
        
        if all([key in context for key in ["redirect_field_name", "redirect_field_value"]]):
            if context["redirect_field_value"]:
                url += "?" + urlencode({
                    context["redirect_field_name"]: context["redirect_field_value"],
                })
        return url
1226434
public function getDefaultNextUrl () {
		if (isset($this->rule->next[$this->nextName]) && is_object($this->rule->next[$this->nextName]) && is_callable($this->rule->next[$this->nextName])) {
			$this->rule->next[$this->nextName] = [
				$this->rule->next[$this->nextName]()
			];
		}
		return isset($this->rule->next[$this->nextName][0]) ? $this->rule->next[$this->nextName][0] : null;
	}
158209
def next(self):
        
        next = request.args.get('next')
        if next is None:
            params = self.default_redirect_params
            next = url_for(self.default_redirect_endpoint, **params)
        return next