PHP Template::replaceIdentifier方法代码示例

 public function renderFrontend()
 {
     $oCriteria = DocumentQuery::create()->filterByDocumentKind('image');
     if (!Session::getSession()->isAuthenticated()) {
         $oCriteria->filterByIsProtected(false);
     }
     if ($this->iCategoryId !== null) {
         $oCriteria->filterByDocumentCategoryId($this->iCategoryId);
     }
     $aDocuments = $oCriteria->find();
     $sTemplateName = 'helpers/gallery';
     try {
         $oListTemplate = new Template($sTemplateName);
         foreach ($aDocuments as $i => $oDocument) {
             $oItemTemplate = new Template($sTemplateName . DocumentListFrontendModule::LIST_ITEM_POSTFIX);
             $oItemTemplate->replaceIdentifier('model', 'Document');
             $oItemTemplate->replaceIdentifier('counter', $i + 1);
             $oDocument->renderListItem($oItemTemplate);
             $oListTemplate->replaceIdentifierMultiple('items', $oItemTemplate);
         }
     } catch (Exception $e) {
         $oListTemplate = new Template("", null, true);
     }
     return $oListTemplate;
 }

 private function listInSidebar(Template $oTemplate)
 {
     $aWidgets = Module::listModulesByType(WidgetModule::getType());
     $oLinks = new Template(TemplateIdentifier::constructIdentifier('links'), null, true);
     foreach ($aWidgets as $sWidgetName => $aWidgetInfo) {
         $oLink = new Template('<a href="{{href}}">{{name}}</a><br />', null, true);
         $oLink->replaceIdentifier('href', LinkUtil::link(array($sWidgetName), get_class()));
         $oLink->replaceIdentifier('name', WidgetModule::getDisplayNameByName($sWidgetName));
         $oLinks->replaceIdentifierMultiple('links', $oLink);
     }
     $oTemplate->replaceIdentifierMultiple('sidebar_content', $oLinks);
 }

 /** send()
  * Description:
  * • This method is called when NewsletterMailer is instanciated
  * • All newsletter, sender and recipient info are ready
  *
  * @return boolean has_invalid email addresses
  */
 public function send()
 {
     // Get newsletter email main template and template body and css by template name
     $oEmailTemplate = new Template('main', array(DIRNAME_TEMPLATES, 'newsletter'));
     $oEmailTemplate->replaceIdentifier('newsletter_template_css', new Template("{$this->oNewsletter->getTemplateName()}.css", array(DIRNAME_TEMPLATES, 'newsletter')));
     // Parse links differently in text
     RichtextUtil::$USE_ABSOLUTE_LINKS = LinkUtil::isSSL();
     $oEMailContent = RichtextUtil::parseStorageForFrontendOutput(stream_get_contents($this->oNewsletter->getNewsletterBody()));
     RichtextUtil::$USE_ABSOLUTE_LINKS = null;
     // Replace add surrounding (body.tmpl) before content if exists. Template needs to contain a newsletter_content identifier
     if (ResourceFinder::findResource(array(DIRNAME_TEMPLATES, NewsletterDetailWidgetModule::NEWSLETTER_DIRNAME, "{$this->oNewsletter->getTemplateName()}.body.tmpl")) !== null) {
         $oEmailTemplate->replaceIdentifier('newsletter_content', new Template("{$this->oNewsletter->getTemplateName()}.body", array(DIRNAME_TEMPLATES, NewsletterDetailWidgetModule::NEWSLETTER_DIRNAME)), null, Template::LEAVE_IDENTIFIERS);
     }
     $oEmailTemplate->replaceIdentifier('newsletter_content', $oEMailContent, null, Template::LEAVE_IDENTIFIERS);
     $oEmailTemplate->replaceIdentifier('subject', $this->oNewsletter->getSubject());
     $oEmailTemplate->replaceIdentifier('language', $this->oNewsletter->getLanguageId());
     $oEmailTemplate->replaceIdentifier('newsletter_link', LinkUtil::absoluteLink($this->oNewsletter->getDisplayLink()));
     $oEmailTemplate->replaceIdentifier('newsletter_date', LocaleUtil::localizeDate(null, $this->oNewsletter->getLanguageId()));
     $oEmailTemplate->replaceIdentifier('newsletter_timestamp', time());
     // Process templates with each recipient, depending on whether recipient is object and object of Subscriber or string
     foreach ($this->aRecipients as $mRecipient) {
         $this->sendNewsletter($mRecipient, clone $oEmailTemplate);
     }
     return count($this->aInvalidEmails) === 0;
 }

 /**
  * @dataProvider validCalculations
  */
 public function testCalculations($sCalculation, $sExpectedResult = '0')
 {
     $oTemplate = new Template(TemplateIdentifier::constructIdentifier('doCalculation', $sCalculation), null, true);
     $oExpected = new Template(TemplateIdentifier::constructIdentifier('result'), null, true);
     $oExpected->replaceIdentifier('result', $sExpectedResult);
     $this->assertSame($oExpected->render(), $oTemplate->render());
 }

 public function testPStringWithHTMLAsTemplate()
 {
     $sString = TranslationPeer::getString('simple_quote', 'de', null, array('quoted' => 'String'));
     $oTemplate = new Template(TemplateIdentifier::constructIdentifier('string'), null, true);
     $oTemplate->replaceIdentifier('string', $sString);
     $this->assertSame(">String<", $oTemplate->render());
 }

 public function getStringAsHTML($sKey, $aParams = array(), $sLanguageId = null, $sDefaultValue = null)
 {
     $mResult = TranslationPeer::getString($sKey, $sLanguageId, $sDefaultValue, $aParams, true);
     $oTemplate = new Template(TemplateIdentifier::constructIdentifier('result'), null, true);
     $oTemplate->replaceIdentifier('result', $mResult);
     return $oTemplate->render();
 }

    public function testSimpleInlineFlagForceHtmlEscape()
    {
        $sTemplateText = <<<EOT
{{test;templateFlag=FORCE_HTML_ESCAPE}}
EOT;
        $oTemplate = new Template($sTemplateText, null, true);
        $oTemplate->replaceIdentifier('test', new Template('<a>&nbsp;</a>', null, true));
        $this->assertSame('&lt;a&gt;&amp;nbsp;&lt;/a&gt;', $oTemplate->render());
    }

    public function testDirectOutputWithIdentifierAndValue()
    {
        $sTemplateText = <<<EOT
test{{id}}test2
EOT;
        $this->expectOutputString('test value test2');
        $oTemplate = new Template($sTemplateText, null, true, true);
        $oTemplate->replaceIdentifier("id", " value ");
    }

 public function display(Template $oTemplate, $bIsPreview = false)
 {
     $sTemplateName = $this->oPage->getTemplateNameUsed();
     $sLanguageId = Session::language();
     $oListTemplate = null;
     $oItemTemplatePrototype = null;
     try {
         $oListTemplate = new Template("search_results/{$sTemplateName}");
         $oItemTemplatePrototype = new Template("search_results/{$sTemplateName}_item");
     } catch (Exception $e) {
         $oListTemplate = new Template("search_results/default");
         $oItemTemplatePrototype = new Template("search_results/default_item");
     }
     $aResults = array();
     $sWords = isset($_REQUEST['q']) ? $_REQUEST['q'] : '';
     if ($sWords) {
         $aWords = StringUtil::getWords($sWords, false, '%');
         $oSearchWordQuery = SearchIndexWordQuery::create();
         foreach ($aWords as $sWord) {
             $sWord = Synonyms::rootFor($sWord);
             $sComparison = Criteria::EQUAL;
             if (strpos($sWord, '%') !== false) {
                 $sComparison = Criteria::LIKE;
             }
             $oSearchWordQuery->addOr(SearchIndexWordPeer::WORD, $sWord, $sComparison);
         }
         $oSearchWordQuery->joinSearchIndex()->useQuery('SearchIndex')->joinPage()->useQuery('Page')->active(true)->filterByIsProtected(false)->endUse()->endUse();
         foreach ($oSearchWordQuery->find() as $oSearchIndexWord) {
             $iId = $oSearchIndexWord->getSearchIndexId();
             if (isset($aResults[$iId])) {
                 $aResults[$iId] += $oSearchIndexWord->getCount();
             } else {
                 $aResults[$iId] = $oSearchIndexWord->getCount();
             }
         }
         arsort($aResults);
     }
     $oListTemplate->replaceIdentifier('count', count($aResults));
     $oListTemplate->replaceIdentifier('search_string', $sWords);
     if (count($aResults) === 0) {
         $oListTemplate->replaceIdentifier('no_results', TranslationPeer::getString('wns.search.no_results', null, null, array('search_string' => $sWords)));
     }
     foreach ($aResults as $iIndexId => $iCount) {
         $oIndex = SearchIndexQuery::create()->findPk(array($iIndexId, $sLanguageId));
         if (!$oIndex || !$oIndex->getPage()) {
             continue;
         }
         $oItemTemplate = clone $oItemTemplatePrototype;
         $oIndex->renderListItem($oItemTemplate);
         $oItemTemplate->replaceIdentifier('count', $iCount);
         $oListTemplate->replaceIdentifierMultiple('items', $oItemTemplate);
     }
     $oTemplate->replaceIdentifier('search_results', $oListTemplate);
 }

 public function onFillPageAttributes($oCurrentPage, $oTemplate)
 {
     $oSearchPage = $oCurrentPage->getPageOfType('search_result');
     if ($oSearchPage === null) {
         return;
     }
     $oTemplate->replaceIdentifier("search_action", LinkUtil::link($oSearchPage->getLinkArray()));
     foreach ($oTemplate->identifiersMatching('search_form', Template::$ANY_VALUE) as $oIdentifier) {
         $oSubTemplate = new Template($oIdentifier->getValue() ? $oIdentifier->getValue() : 'default', array(DIRNAME_TEMPLATES, 'search_form'));
         $oSubTemplate->replaceIdentifier("search_action", LinkUtil::link($oSearchPage->getLinkArray()));
         $oTemplate->replaceIdentifier($oIdentifier, $oSubTemplate);
     }
 }

 /**
  * renderFile()
  * @return string xhtml output
  */
 public function renderFile()
 {
     $oOutput = new XHTMLOutput(XHTMLOutput::SETTING_HTML_4_TRANSITIONAL, true, null, $this->oNewsletter->getLanguageId());
     $oOutput->render();
     $oNewsletterTemplate = new Template('main_display', array(DIRNAME_TEMPLATES, 'newsletter'), false, true);
     $oNewsletterTemplate->replaceIdentifier('newsletter_template_css', new Template("{$this->oNewsletter->getTemplateName()}.css", array(DIRNAME_TEMPLATES, 'newsletter')));
     $oNewsletterContent = RichtextUtil::parseStorageForFrontendOutput(stream_get_contents($this->oNewsletter->getNewsletterBody()));
     if (ResourceFinder::findResource(array(DIRNAME_TEMPLATES, NewsletterDetailWidgetModule::NEWSLETTER_DIRNAME, "{$this->oNewsletter->getTemplateName()}.body.tmpl")) !== null) {
         $oNewsletterTemplate->replaceIdentifier('newsletter_content', new Template("{$this->oNewsletter->getTemplateName()}.body", array(DIRNAME_TEMPLATES, NewsletterDetailWidgetModule::NEWSLETTER_DIRNAME)), null, Template::LEAVE_IDENTIFIERS);
     }
     $oNewsletterTemplate->replaceIdentifier('newsletter_content', $oNewsletterContent, null, Template::LEAVE_IDENTIFIERS);
     $oNewsletterTemplate->replaceIdentifier('language', $this->oNewsletter->getLanguageId());
     if ($this->oMailing !== null) {
         $oNewsletterTemplate->replaceIdentifier('newsletter_date', LocaleUtil::localizeDate($this->oMailing->getDateSent(null)->getTimestamp(), $this->oNewsletter->getLanguageId()));
         $oNewsletterTemplate->replaceIdentifier('newsletter_timestamp', $this->oMailing->getDateSent(null)->getTimestamp());
     } else {
         $oNewsletterTemplate->replaceIdentifier('newsletter_date', LocaleUtil::localizeDate($this->oNewsletter->getCreatedAt(null)->getTimestamp(), $this->oNewsletter->getLanguageId()));
         $oNewsletterTemplate->replaceIdentifier('newsletter_timestamp', $this->oNewsletter->getCreatedAt(null)->getTimestamp());
     }
     $oNewsletterTemplate->replaceIdentifier('recipient', TranslationPeer::getString('wns.newsletter.recipient', $this->oNewsletter->getLanguageId()));
     $oNewsletterTemplate->replaceIdentifier('subject', $this->oNewsletter->getSubject());
     $oNewsletterTemplate->render();
 }

 public function renderListItem(Template $oTemplate)
 {
     $oTemplate->replaceIdentifier("id", $this->getId());
     $oTemplate->replaceIdentifier("name", $this->getPage()->getName());
     $oTemplate->replaceIdentifier("link_text", $this->getLinkText());
     $oTemplate->replaceIdentifier("title", $this->getPageTitle());
     $oTemplate->replaceIdentifier("description", $this->getPage()->getDescription());
     $oTemplate->replaceIdentifier("url", $this->getLink());
 }

 public function testTypesInArrayReplace()
 {
     $oTestTemplate = new Template('{{test}}', null, true);
     $oTestTemplate->replaceIdentifier('test', array('SAMPLE', 1, 9999999999.0, 3.1415972, new TagWriter('a')));
     $this->assertSame("SAMPLE199999999993.1415972<a></a>", $oTestTemplate->render());
 }

    public function testIdentifierEscaping()
    {
        $sTemplateText = <<<EOT
{{test=\\\\}}{{test=\\{\\{t1=\\\\\\\\\\\\}\\}\\}}}{{test=val2}}
EOT;
        $oTemplate = new Template($sTemplateText, null, true);
        $this->assertSame("{{test=\\\\}}{{test=\\{\\{t1\\=\\\\\\}\\}\\}}}{{test=val2}}", $oTemplate->__toString());
        $oTemplate->replaceIdentifier('test', "val", '\\', Template::NO_IDENTIFIER_VALUE_REPLACEMENT);
        $this->assertSame("val{{test=\\{\\{t1\\=\\\\\\}\\}\\}}}{{test=val2}}", $oTemplate->__toString());
        $oTemplate->replaceIdentifier('t1', "val2");
        $this->assertSame("val{{test=\\{\\{t1\\=\\\\\\}\\}\\}}}{{test=val2}}", $oTemplate->__toString());
        /// @todo
        // $oTemplate->replaceIdentifier('t1', "val3", '\\}');
        // $this->assertSame("val{{test=val3}}{{test=val2}}", $oTemplate->__toString());
        $this->assertSame("val", $oTemplate->render());
    }

 public static function getString($sKey, $sLanguageId = null, $sDefaultValue = null, $aParameters = null, $bMayReturnTemplate = false, $iFlags = 0)
 {
     $bNoHTMLInReturnedString = $bMayReturnTemplate === null;
     if (Settings::getSetting('frontend', 'display_string_keys', false)) {
         return $sKey;
     }
     if (!is_string($sDefaultValue)) {
         $sDefaultValue = "Translation missing: {$sKey}";
     }
     if ($sLanguageId === null) {
         $sLanguageId = Session::language();
     }
     $oString = self::retrieveByPK($sLanguageId, $sKey);
     $sString = '';
     if ($oString === null) {
         $sString = self::getStaticString($sKey, $sLanguageId);
         if ($sString === null) {
             return $sDefaultValue;
         }
     } else {
         $sString = $oString->getText();
     }
     if (is_array($aParameters) && count($aParameters) > 0 || strpos($sString, TEMPLATE_IDENTIFIER_START) !== false) {
         if (!is_array($aParameters)) {
             $aParameters = array();
         }
         if (!$bMayReturnTemplate) {
             //NO_HTML_ESCAPE works in any case:
             //Case $bMayReturnTemplate === false: strings will always be included in templates and thus always be encoded correctly in a second step.
             //Case $bMayReturnTemplate === null: strings should not contain any HTML-characteristics, including entities. {{br}}-Tags will be stripped as well.
             $iFlags = $iFlags | Template::NO_HTML_ESCAPE;
         }
         if ($bMayReturnTemplate) {
             //If returned item is a template, it is assumed that nothing will run htmlentities on it later on so we have to run it now.
             $sString = Template::htmlEncode($sString);
         }
         if ($bNoHTMLInReturnedString) {
             $sString = str_replace('{{br}}', "\n", $sString);
         }
         $tmpl = new Template($sString, "db", true, false, Settings::getSetting("encoding", "db", "utf-8"), null, $iFlags);
         foreach ($aParameters as $sKey => $sValue) {
             $tmpl->replaceIdentifier($sKey, $sValue);
         }
         if ($bMayReturnTemplate) {
             return $tmpl;
         }
         $sString = $tmpl->render();
     }
     return $sString;
 }