Returns widget start non SSL URL including widget.php and sid.

@param int   $languageId    language
@param bool  $inAdmin       if admin
@param array $urlParameters parameters which should be added to URL.

@return string
354922
public function getWidgetUrl($languageId = null, $inAdmin = null, $urlParameters = [])
    {
        $utilsUrl = Registry::getUtilsUrl();
        $widgetUrl = $this->isSsl() ? $this->getSslShopUrl($languageId) : $this->getShopUrl($languageId, $inAdmin);
        $widgetUrl = $utilsUrl->processUrl($widgetUrl . 'widget.php', false);

        if (!isset($languageId)) {
            $language = Registry::getLang();
            $languageId = $language->getBaseLanguage();
        }
        $urlLang = $utilsUrl->getUrlLanguageParameter($languageId);
        $widgetUrl = $utilsUrl->appendUrl($widgetUrl, $urlLang, true);

        $widgetUrl = $utilsUrl->appendUrl($widgetUrl, $urlParameters, true, true);

        return $widgetUrl;
    }
46575
public function getDefaultUrl($language = null)
    {
        foreach ($this->urls as $url) {
            if ($url->isDefault()) {
                return $url;
            }
        }

        return null;
    }
1170868
public function resolve_language_url($currentPageID, $sectionID)
    {
        $resolve = ['/'];
        $lang = Section::getByID((int) $sectionID);
        if (is_object($lang)) {
            $resolve = [$lang];
            $page = \Page::getByID((int) $currentPageID);
            if (!$page->isError()) {
                $relatedID = $lang->getTranslatedPageID($page);
                if ($relatedID) {
                    $pc = \Page::getByID($relatedID);
                    $resolve = [$pc];
                } elseif ($page->isGeneratedCollection()) {
                    $this->app->make('session')->set('multilingual_default_locale', $lang->getLocale());
                    $resolve = [$page];
                }
            }
        }

        return $this->app->make(ResolverManagerInterface::class)->resolve($resolve);
    }
818494
public function getRawObjectByUid(int $uid, int $languageUid = 0, array $querySettings = ['respectSysLanguage' => false]) {
    if ($uid && $uid > 0) {
      // Create a new query.
      $query = $this->createquery();

      // Set the passend language UID.
      $settings = $query->getQuerySettings();
      $settings->setLanguageUid($languageUid);

      // Apply the passed query settings.
      $query = $this->applyQuerySettings($query, $querySettings);

      // Set the query constraints.
      $query->matching($query->equals('uid', $uid));

      // Execute the query and get raw object.
      $result = $query->execute(true);

      return $result[0];
    }

    return null;
  }
1043616
public function sslStart($domain, $ip = null, $token = null)
    {
        $headers = [
            'connect_timeout' => 60,
            'timeout' => 60,
            'debug' => false,
            'form_params' => [
                'domain' => $domain.':443',
                'show_test_results' => 'false',
                'recheck' => 'true',
                'verbosity' => '0'
            ]
        ];

        if ((! is_null($ip)) && (! is_null($token))) {
            $headers['form_params']['choosen_ip'] = $ip[0];
            $headers['form_params']['token'] = $token;
        }

        try {
            $response = $this->client->post('https://www.htbridge.com/ssl/api/v1/check/'.time().'.html', $headers);
            return json_decode($response->getBody()->getContents(), true);
        } catch (Exception $e) {
            app(Eye::class)->logger()->error('Unable to start SSL scan', $e, $domain);
        }

        return null;
    }
1255658
public function getLicenseContent($languageId)
    {
        $licensePathElements = [
            $this->getSetupDirectory(),
            ucfirst($languageId),
            self::LICENSE_TEXT_FILENAME
        ];
        $licensePath = implode(DIRECTORY_SEPARATOR, $licensePathElements);

        $licenseContent = $this->getFileContents($licensePath);

        return $licenseContent;
    }
1072549
public static function t($id, array $parameters = [], $domain = null, $locale = null)
    {
        @trigger_error('The '.__METHOD__.' method is deprecated since version 3.0 and will be removed in 4.0.', E_USER_DEPRECATED);

        return App::getInstance()->getComponent('translator')->trans($id, $parameters, $domain, $locale);
    }
844623
protected function generateStandardUrl(array $urlParameters = array(), $absolute = false)
    {
        if (parent::isCurrent())
        {
            return '#'.$this->getAnchor();
        }
        
        return parent::generateStandardUrl($urlParameters, $absolute);
    }
1314511
public function trans($id, array $parameters = [], $domain = null, $locale = null)
    {
        $domain = $domain ?? $this->config->getDefaultDomain();
        $locale = $locale ?? $this->locale;

        $message = $this->get($locale, $domain, $id);

        return self::interpolate($message, $parameters);
    }
1252004
public function findByPageIdAndByLanguageId($pageId, $languageId)
    {
        try {
            $this->initializeSearch($pageId, $languageId);
            $pageQuery = $this->queryBuilder->buildPageQuery($pageId);
            $response = $this->search->search($pageQuery, 0, 10000);
        } catch (NoSolrConnectionFoundException $exception) {
            return [];
        } catch (SolrCommunicationException $exception) {
            return [];
        }
        $data = $response->getParsedData();
        return $this->documentEscapeService->applyHtmlSpecialCharsOnAllFields($data->response->docs ?? []);
    }
1045072
public function getPlaceById($id, array $extensions = [], $language = null)
    {
        $this->validateExtension($extensions);
        $extensions = implode(',', $extensions);

        $body = array_merge(
            ['placeid' => $id],
            !empty($extensions) ? ['extensions' => $extensions] : [],
            null !== $language ? ['language' => $language] : []
        );

        return $this->get(self::URL, $body);
    }
1133746
public function getLanguageBySite($siteId)
    {
        if ($this->hasLanguageBySite($siteId)) {
            return $this->languageBySites[self::SITE_ID_PREFIX.$siteId];
        }

        return null;
    }
149779
public function getPages($uids, int $languageUid = null): array {
    $pages = [];

    if (is_string($uids)) {
      $uids = GeneralUtility::intExplode(',', $uids, true);
    }

    if ($uids) {
      foreach($uids as $uid) {
        $record = $this->getPage($uid, $languageUid);

        if ($record) {
          $pages[] = $record;
        }
      }
    }

    return $pages;
  }
114622
public function bindModuleUrl($modulename, $xsl="", $lang="")
	{
		$queryStart = strpos($modulename, "?");
		$queryString = "";

		if ($queryStart!==false)
		{
			$queryString = "&" . substr($modulename, $queryStart+1);
			$modulename = substr($modulename, 0, $queryStart);
		}

		if (strpos($modulename, "module:") !== false)
		{
			$modulename = substr($modulename, 7);
		}

		if(empty($xsl))
		{
			if ($this->getXsl()=="index")
			{
				$xsl = 	$this->get("xmlnuke.DEFAULTPAGE");

			}
			else
			{
				$xsl = $this->getXsl();
			}
		}

		if(empty($lang))
			$lang = strtolower($this->Language()->getName());


		$fullLink = $this->get("xmlnuke.USEFULLPARAMETER");
		if (!$fullLink)
		{
			if ($xsl == $this->get("xmlnuke.DEFAULTPAGE"))
			{
				$xsl = "";
			}
			$array = array_keys($this->LanguagesAvailable());
			if ($lang == $array[0])
			{
				$lang = "";
			}
		}

		$url = $this->UrlModule()."?module=".$modulename;
		$url .= $queryString;
		if ($xsl != "")
		{
			$url .= "&xsl=".$xsl;
		}
		if ($lang != "")
		{
			$url .= "&lang=".$lang;
		}

		return $url;
	}
515889
public function getUserMsg($openid, $lang = 'zh_CN')
    {
        $queryStr = [
            'openid' => $openid,
            'lang'   => $lang,
        ];

        $res = $this->_get('info', $queryStr);

        return $res;
    }
309698
public static function urlLink($text, $url, $parameters = [], $secure = null)
    {
        return $this->createElement('a')->text($text)
            ->href(url($url, $parameters, $secure));
    }
662893
public static function getLanguageTranslateByIdAndLanguageId($id, $languageId)
    {
        $languageTranslate = self::findOne(['id' => $id, 'language' => $languageId]);
        if (!$languageTranslate) {
            $languageTranslate = new self([
                'id' => $id,
                'language' => $languageId,
            ]);
        }

        return $languageTranslate;
    }