Last commit: Wed Feb 15 00:22:28 2023 +0100	Jan Dankert	Fix: Changing the Longtext format was not possible.


      <?php
      
      
      namespace cms\generator;
      
      
      use cms\base\Configuration;
      use cms\generator\PageContext;
      use cms\model\File;
     use cms\model\Folder;
     use cms\model\Language;
     use cms\model\Link;
     use cms\model\Page;
     use cms\model\Project;
     use cms\model\Template;
     use cms\model\TemplateModel;
     use cms\model\Value;
     use logger\Logger;
     use template_engine\components\html\component_else\ElseComponent;
     use util\exception\GeneratorException;
     use util\exception\ObjectNotFoundException;
     use util\Mustache;
     use util\Text;
     use util\text\TextMessage;
     
     
     class PageGenerator extends BaseGenerator
     {
     
     	/**
     	 * PageGenerator constructor.
     	 * @param $pageContext PageContext
     	 */
     	public function __construct($pageContext )
     	{
     		$this->context = $pageContext;
     	}
     
     
     
     	/**
     	 * Erzeugen der Inhalte zu allen Elementen dieser Seite
     	 * wird von generate() aufgerufen.
     
     	 * @param $page Page page
     	 * @return array
     	 * @throws GeneratorException
     	 */
     	protected function generatePageElements( $page )
     	{
     		$values = array();
     
     		$elements = $page->getTemplate()->getElements();
     
     		foreach( $elements as $elementid=>$element )
     		{
     			// neues Inhaltobjekt erzeugen
     			$valueContext = new ValueContext($this->context);
     			$valueContext->elementid = $elementid;
     			$valueGenerator = new ValueGenerator( $valueContext );
     			try {
     				$values[$elementid] = $valueGenerator->getCache()->get();
     			} catch( \Exception $e ) {
     				// Unrecoverable Error while generating the content.
     				Logger::info( $e );
     
     				throw new GeneratorException("Element '".$element->name."' could not be generated.",$e);
     			}
     
     		}
     
     		return $values;
     	}
     
     
     
     	/**
     	 * Erzeugen des Inhaltes der gesamten Seite.
     	 *
     	 * @return String Inhalt
     	 * @throws GeneratorException|ObjectNotFoundException
     	 */
     	private function generatePageValue()
     	{
     		// Setzen der 'locale', damit sprachabhängige Systemausgaben (wie z.B. die
     		// Ausgabe von strftime()) in der korrekten Sprache dargestellt werden.
     		$language = new Language($this->context->languageId);
     		$language->load();
     
     		$language->setCurrentLocale();
     
     		$page = new Page( $this->context->objectId );
     		$page->load();
     
     		$tplGenerator = new TemplateGenerator( $page->templateid,$this->context->modelId, $this->context->scheme );
     
     		try {
     			$pageValues = $this->generatePageElements($page); // generating the value of all page elements.
     		}
    		catch( \Exception $e ) {
    			throw new GeneratorException("Page '".$page->getName()."' could not be generated.",$e);
    		}
    
    		// Template should have access to the page properties.
    		// Template should have access to the settings of this node object.
    		$data = [];
    		$data['_page'         ] = $page->getProperties()   ;
    		$data['_localsettings'] = $page->getSettings()     ;
    		$data['_settings'     ] = $page->getTotalSettings();
    
    		foreach( $page->getTemplate()->getElements() as $elementId=>$element )
    			$data[ $element->name ] = $pageValues[$elementId];
    
    		return $tplGenerator->generateValue( $data );
    	}
    
    	protected function generate()
    	{
    		try {
    			return $this->generatePageValue();
    		} catch( GeneratorException $e ) {
    
    			throw new GeneratorException('Could not render page '.$this->context->getObjectId(),$e );
    		}
    
    	}
    
    
    	/**
    	 * Creating the public filename of a page.
    	 *
    	 * @return string
    	 * @throws \util\exception\ObjectNotFoundException
    	 */
    	public function getPublicFilename()
    	{
    		$page = new Page( $this->context->sourceObjectId );
    		$page->load();
    
    		$parentFolder = new Folder( $page->parentid );
    		$parentFolder->load();
    
    		$project = $page->getProject();
    		$project->load();
    
    		$publishConfig = Configuration::subset('publish');
    		$format = $publishConfig->get('format','{filename}{language_sep}{language}{type_sep}{type}');
    		$format = str_replace('{filename}',$page->filename(),$format );
    
    		$allLanguages = $project->getLanguageIds();
    		$allModels    = $project->getModelIds();
    
    		$withLanguage = count($allLanguages) > 1 || $publishConfig->get('filename_language','auto'   ) == 'always';
    		$withModel    = count($allModels   ) > 1 || $publishConfig->get('filename_type'    ,'always' ) == 'always';
    
    		$languagePart = '';
    		$typePart     = '';
    
    		if	( $withLanguage  ) {
    			$l = new Language( $this->context->languageId );
    			$l->load();
    
    			$languagePart = $l->isoCode;
    		}
    
    		if	( $withModel ) {
    			$templateModel = new TemplateModel( $page->templateid, $this->context->modelId );
    			$templateModel->load();
    
    			$typePart = $templateModel->extension;
    		}
    
    		$languageSep = $languagePart? $publishConfig->get('language_sep','.') :'';
    		$typeSep     = $typePart    ? $publishConfig->get('type_sep'    ,'.') :'';
    
    		$format = str_replace('{language}'    ,$languagePart ,$format );
    		$format = str_replace('{language_sep}',$languageSep  ,$format );
    		$format = str_replace('{type}'        ,$typePart     ,$format );
    		$format = str_replace('{type_sep}'    ,$typeSep      ,$format );
    
    		return $page->path().'/'.$format;
    	}
    
    
    
    	public function getMimeType()
    	{
    		$page = new Page( $this->context->sourceObjectId );
    		$page->load();
    		$templateModel = new TemplateModel( $page->templateid,$this->context->modelId );
    		$templateModel->load();
    
    		return $templateModel->mimeType();
    	}
    }


Download modules/cms/generator/PageGenerator.class.php

History
Wed, 15 Feb 2023 00:22:28 +0100	Jan Dankert	Fix: Changing the Longtext format was not possible.
Sat, 28 Jan 2023 19:10:47 +0100	Jan Dankert	New: Templates may be rendered as Mustache, Script and Script template.
Sat, 2 Jul 2022 00:37:22 +0200	Jan Dankert	Fix: Public Filename must consider the filename style.
Fri, 18 Mar 2022 22:38:42 +0100	dankert	Refactoring: Extracted the TemplateGenerator out of the PageGenerator.
Fri, 11 Mar 2022 19:26:18 +0100	dankert	Performance: Do "print_r" only in development mode.
Sun, 5 Dec 2021 22:26:39 +0100	dankert	Fixed a type in template source of new projects.
Sun, 5 Dec 2021 20:33:24 +0100	dankert	Cleanup: Removed unusable properties from class 'Value' and 'BaseObject'.
Tue, 9 Nov 2021 23:52:56 +0100	Jan Dankert	Some fixes for reading content from the new content table.
Sun, 14 Mar 2021 02:23:39 +0100	Jan Dankert	Fix: Pasted crap...
Sun, 14 Mar 2021 02:14:31 +0100	Jan Dankert	Fix: The public filename of files must contain their path...
Thu, 4 Mar 2021 02:24:45 +0100	Jan Dankert	New: The calculation of the mime types should be done in the generators.
Sat, 27 Feb 2021 02:10:16 +0100	Jan Dankert	Fix: Using the correct object-id for generating the page.
Sun, 1 Nov 2020 03:08:55 +0100	Jan Dankert	Replaced the calls to "Configuration::rawConfig()" with the OO style calls; Cleanup LoginAction.
Sun, 1 Nov 2020 00:36:50 +0100	Jan Dankert	Refactoring: Only using the configuration object.
Mon, 26 Oct 2020 22:21:42 +0100	Jan Dankert	Refactoring: Using TextMessage for creating Messages with user content.
Tue, 29 Sep 2020 22:17:11 +0200	Jan Dankert	Refactoring: Do not use global constants.
Sat, 26 Sep 2020 10:32:02 +0200	Jan Dankert	Refactoring: No global $conf array any more.
Sat, 26 Sep 2020 04:26:55 +0200	Jan Dankert	Refactoring: read configuration values with a class.
Wed, 23 Sep 2020 01:04:05 +0200	Jan Dankert	Cleanup of deprecated methods and deprecated class attributes.
Mon, 21 Sep 2020 22:48:59 +0200	Jan Dankert	Complexe refactoring: Moving all generation logic from the model (Value,Page,File) to generators classes.