Returns URL to rate a comment.

@param bool $bPositiveLink Set if you want the url to rate a review positive or negative
@param bool $bUseFullUrl

@return string
169455
public function GetRateURL($bPositiveLink = true, $bUseFullUrl = false)
    {
        if ($bPositiveLink) {
            $bPositiveLink = '1';
        } else {
            $bPositiveLink = '0';
        }
        $aParameter = array('bRate' => $bPositiveLink, TdbShopArticleReview::URL_PARAM_REVIEW_ID => $this->id);
        $sRatePositiveLink = TTools::GetExecuteMethodOnCurrentModuleURL('RateReview', $aParameter, $bUseFullUrl);

        return $sRatePositiveLink;
    }
1065257
public function _link($title, $url = null, $options = array(), $confirmMessage = false) {
			
		$escapeTitle = true;
		if($url === null) {
			$url = $this->url($title,true);
			$title = htmlspecialchars_decode($url, ENT_QUOTES);
			$title = h(urldecode($title));
			$escapeTitle = false;
		} elseif($url !== false){
			$url = $this->url($url,true);	
		}
		
	

		if (isset($options['escapeTitle'])) {
			$escapeTitle = $options['escapeTitle'];
			unset($options['escapeTitle']);
		} elseif (isset($options['escape'])) {
			$escapeTitle = $options['escape'];
		}

		if ($escapeTitle === true) {
			$title = h($title);
		} elseif (is_string($escapeTitle)) {
			$title = htmlentities($title, ENT_QUOTES, $escapeTitle);
		}

		if (!empty($options['confirm'])) {
			$confirmMessage = $options['confirm'];
			unset($options['confirm']);
		}
		if ($confirmMessage) {
			$options['onclick'] = $this->_confirm($confirmMessage, 'return true;', 'return false;', $options);
		} elseif (isset($options['default']) && !$options['default']) {
			if (isset($options['onclick'])) {
				$options['onclick'] .= ' ';
			} else {
				$options['onclick'] = '';
			}
			$options['onclick'] .= 'event.returnValue = false; return false;';
			unset($options['default']);
		}

		if ($url === false) {
			return sprintf($this->_tags['linknohref'], $this->_parseAttributes($options), $title);
		}		
		return sprintf($this->_tags['link'], $url, $this->_parseAttributes($options), $title);
	}
314569
public function get_url() {
        if ($this->anonymous) {
            return new \moodle_url('/mod/feedback/show_entries.php', array('id' => $this->other['cmid'],
                    'showcompleted' => $this->objectid));
        } else {
            return new \moodle_url('/mod/feedback/show_entries.php' , array('id' => $this->other['cmid'],
                    'userid' => $this->userid, 'showcompleted' => $this->objectid));
        }
    }
661154
protected function get_review_link() {
		if ( false === $this->op['review_link'] ) {
			$link = '';
			if ( 'wordpress' === $this->op['site'] ) {
				$link = 'https://wordpress.org/support/';

				switch ( $this->op['type'] ) {
					case 'theme':
						$link .= 'theme/';
						break;
					case 'plugin':
						$link .= 'plugin/';
						break;
				}

				$link .= $this->op['type'] . '/reviews';

				$link = \add_query_arg( 'rate', $this->op['rating'], $link ) . \esc_url( $link . '#new-post' );
			} elseif ( 'codecanyon' === $this->op['site'] ) {
				$link = 'https://codecanyon.net/item/x/reviews/' . $this->op['item_id'] . '#rating-' . $this->op['item_id'];
			} elseif ( 'themeforest' === $this->op['site'] ) {
				$link = 'https://themeforest.net/item/x/reviews/' . $this->op['item_id'] . '#rating-' . $this->op['item_id'];
			}

			return $link;
		}

		return $this->op['review_link'];
	}
435304
public function getEvidenceURL($urlSuffix = null)
    {
        if (is_null($urlSuffix)) {
            $urlSuffix = $this->evidence;
        }

        $url = $this->url.$this->prefix.'/'.$this->company;
        if (!empty($urlSuffix)) {
            $url .= (($urlSuffix[0] == '.') ? '' : '/').$urlSuffix;
        }
        return $url;
    }
1032766
protected function getServiceDescription($baseUrl)
    {
        return new Description(
            array(
                'baseUrl' => $baseUrl,
                'operations' => array(
                    'lookup' => array(
                        'uri' => 'postcodes/{postcode}',
                        'httpMethod' => 'GET',
                        'responseModel' => 'getResponse',
                        'parameters' => array(
                            'postcode' => array(
                                'location' => 'uri',
                                'description' => 'The postcode to look up.',
                                'required' => true
                            )
                        )
                    ),
                    'bulkLookup' => array(
                        'uri' => 'postcodes',
                        'httpMethod' => 'POST',
                        'responseModel' => 'getResponse',
                        'parameters' => array(
                            'postcodes' => array(
                                'location' => 'postField',
                                'description' => 'The postcodes to look up (max 100).',
                                'required' => true
                            )
                        )
                    ),
                    'reverseGeocode' => array(
                        'uri' => 'postcodes/lon/{longitude}/lat/{latitude}',
                        'httpMethod' => 'GET',
                        'responseModel' => 'getResponse',
                        'parameters' => array(
                            'longitude' => array(
                                'location' => 'uri',
                                'description' => 'The longitude to look up.',
                                'required' => true
                            ),
                            'latitude' => array(
                                'location' => 'uri',
                                'description' => 'The latitude to look up.',
                                'required' => true
                            ),
                            'limit' => array(
                                'location' => 'query',
                                'description' => 'Limit the number of postcodes returned (default 10, max 100).',
                                'required' => true
                            ),
                            'radius' => array(
                                'location' => 'query',
                                'description' => 'Limit the postcodes returned in metres (default 100, max 1000).',
                                'required' => true
                            )
                        )
                    ),
                    'bulkReverseGeocode' => array(
                        'uri' => 'postcodes',
                        'httpMethod' => 'POST',
                        'responseModel' => 'getResponse',
                        'parameters' => array(
                            'geolocations' => array(
                                'location' => 'postField',
                                'description' => 'The latitude and longitude coordinates to look up.',
                                'required' => true
                            )
                        )
                    ),
                    'matching' => array(
                        'uri' => 'postcodes',
                        'httpMethod' => 'GET',
                        'responseModel' => 'getResponse',
                        'parameters' => array(
                            'query' => array(
                                'location' => 'query',
                                'description' => 'The postcode query.'
                            ),
                            'limit' => array(
                                'location' => 'query',
                                'description' => 'Limit the number of postcodes returned (default 10, max 100).'
                            )
                        )
                    ),
                    'validate' => array(
                        'uri' => 'postcodes/{postcode}/validate',
                        'httpMethod' => 'GET',
                        'responseModel' => 'getResponse',
                        'parameters' => array(
                            'postcode' => array(
                                'location' => 'uri',
                                'description' => 'The postcode to validate.',
                                'required' => true
                            )
                        )
                    ),
                    'autocomplete' => array(
                        'uri' => 'postcodes/{postcode}/autocomplete',
                        'httpMethod' => 'GET',
                        'responseModel' => 'getResponse',
                        'parameters' => array(
                            'postcode' => array(
                                'location' => 'uri',
                                'description' => 'The partial postcode to autocomplete.',
                                'required' => true
                            ),
                            'limit' => array(
                                'location' => 'query',
                                'description' => 'Limit the number of postcodes returned (default 10, max 100).'
                            )
                        )
                    ),
                    'random' => array(
                        'uri' => 'random/postcodes',
                        'httpMethod' => 'GET',
                        'responseModel' => 'getResponse',
                    ),
                    'outwardCodeLookup' => array(
                        'uri' => 'outcodes/{outcode}',
                        'httpMethod' => 'GET',
                        'responseModel' => 'getResponse',
                        'parameters' => array(
                            'outcode' => array(
                                'location' => 'uri',
                                'description' => 'The outward code (first half of postcode) to get location data for.',
                                'required' => true
                            )
                        )
                    )
                ),
                'models' => array(
                    'getResponse' => array(
                        'type' => 'object',
                        'properties' => array(
                            'statusCode' => array(
                                'location' => 'statusCode'
                            )
                        ),
                        'additionalProperties' => array(
                            'location' => 'json'
                        )
                    )
                )
            )
        );
    }
1214241
public function url($token, $url, $payload = null, $type = 'GET')
    {
        $this->validateUrl($url);

        switch (get_class($token)) {
            case 'Claroline\CoreBundle\Entity\Oauth\FriendRequest': return $this->adminQuery($token, $url, $payload, $type);
            //maybe later, we'll use this method to fetch resources & stuff from an other platform...
            //case 'Claroline\CoreBundle\Entity\Oauth\UserToken': return $this->userQuery($token, $url, $payload, $type);
        }
    }
201190
private function apiUrl($url = '', $format = 'json')
    {
        if (!$url) {
            return false;
        }

        $absUrl = sprintf('https://%s/pms/v%d/%s/%s', 
                          $this->apiBase,
                          $this->version,
                          $format,
                          $url);

        return (string) $absUrl;
    }
65898
public function listed(string $url, $returnType = false)
    {
        if (empty($this->apiKey)) {
            throw new Exception('A Google Safebrowsing API key has not been specified');
        }

        // Retrieve the result from SafeBrowsing
        $result = $this->getSafebrowsingResult($url);

        // Check for exististance of the supplied URL in any matches
        if (is_object($result) and isset($result->matches)) {
            foreach ($result->matches as $match) {
                if ($match->threat->url == $url) {
                    // Return the Threat Type if requested,
                    // otherwise return true
                    if ($returnType) {
                        return $match->threatType;
                    }
                    
                    return true;
                }
            }
        }

        return false;
    }
233437
public function getTokenAnswerLink($tokenId, $tokenStatus, $keepCaps)
    {
        if ('A' == $tokenStatus || 'P' == $tokenStatus || 'I' == $tokenStatus) {
            $menuItem = $this->_getAnswerMenuItem();
            $label    = $menuItem->get('label');

            $link = $menuItem->toActionLink(
                ($keepCaps ? $label : strtolower($label)),
                [
                    'gto_id_token' => $tokenId,
                    'gto_in_source' => 1,
                    \Gems_Model::ID_TYPE => 'token',
                ]);

            if ($link) {
                $link->title = sprintf($this->_('See answers for token %s'), strtoupper($tokenId));

                return $link;
            }

        }
    }
1327114
public function getBackLink($fallback = '')
    {
        $url = '';

        if ($this->owner->Request) {
            if ($this->owner->Request->requestVar('BackURL')) {
                $url = $this->owner->Request->requestVar('BackURL');
            } else {
                if ($this->owner->Request->isAjax() && $this->owner->Request->getHeader('X-Backurl')) {
                    $url = $this->owner->Request->getHeader('X-Backurl');
                } else {
                    if ($this->owner->Request->getHeader('Referer')) {
                        $url = $this->owner->Request->getHeader('Referer');
                    }
                }
            }
        }

        if (!$url) {
            $url = $fallback ? $fallback : singleton('director')->baseURL();
        }

        return $url;
    }
878425
public function get_comments( $count = null, $order = 'wp', $type = 'comment', $status = 'approve', $CommentClass = 'Timber\Comment' ) {
		return $this->comments($count, $order, $type, $status, $CommentClass);
	}
573121
public function getTopicUrl(Tag $tag, array $parameters = [], bool $schemeRelative = false): string
    {
        return $this->topicUrlGenerator->generate(
            $tag,
            $parameters,
            $schemeRelative ?
                UrlGeneratorInterface::NETWORK_PATH :
                UrlGeneratorInterface::ABSOLUTE_URL
        );
    }
913936
public function evidenceUrlWithSuffix($urlSuffix)
    {
        $evidenceUrl = $this->getEvidenceUrl();
        if (!empty($urlSuffix)) {
            if (($urlSuffix[0] != '/') && ($urlSuffix[0] != ';') && ($urlSuffix[0]
                != '?')) {
                $evidenceUrl .= '/';
            }
            $evidenceUrl .= $urlSuffix;
        }
        return $evidenceUrl;
    }
993247
public function getIcalURL($base_url = '', array $params = array()) {

		$user = elgg_get_logged_in_user_entity();

		$params['view'] = 'ical';
		$params['u'] = $user->guid;
		$params['t'] = $this->getUserToken($user->guid);

		$url = elgg_http_add_url_query_elements($base_url, $params);
		return elgg_normalize_url($url);
	}
81571
public function getComment()
    {
        $id = isset($this->urlParams['ID']) ? $this->urlParams['ID'] : false;

        if ($id) {
            /** @var Comment $comment */
            $comment = Comment::get()->byId($id);
            if ($comment) {
                $this->fallbackReturnURL = $comment->Link();
                return $comment;
            }
        }

        return false;
    }
1006818
public function getPreviewUrl()
    {
        if ($domain = $this->getBaseProperty('preliminaryDomain')) {
            $https = Kwf_Util_Https::domainSupportsHttps($domain);
            $protocol = $https ? 'https' : 'http';
            $url = $protocol . '://'.$domain.$this->url;
        } else {
            $url = $this->getAbsoluteUrl();
        }
        return Kwf_Setup::getBaseUrl().'/admin/component/preview/?url='.urlencode($url.'?kwcPreview');
    }