<?php
/*
   +----------------------------------------------------------------------+
   | Netautor Professional Application Server                             |
   +----------------------------------------------------------------------+
   | Copyright (C) 1998-2001 digiconcept GmbH. <www.digiconcept.net>      |
   +----------------------------------------------------------------------+
   | This file is subject to license, that is bundled with this package   |
   | in the file LICENSE.TXT, and is available at through the             |
   | world-wide-web at http://www.netautor.com/license/                   |
   |                                                                      |
   | If you did not receive a copy of the license and are unable to       |
   | obtain it through the world-wide-web, please send a note to          |
   | license@netautor.com so we can mail you a copy.                      |
   +----------------------------------------------------------------------+
   | Authors: Stefan Rottensteiner <stefan.rottensteiner@netautor.com>    |
   |          Gregor Wollner       <gregor.wollner@netautor.com>          |
   |          Helli  Kleinhans     <helli.kleinhans@netautor.com>         |
   +----------------------------------------------------------------------+
 */

/**
 * Script das die nötige Umgebung für die Layouts zusammenstellt
 *
 * @autor 	Helmut Kleinhans
 * @version 4.2
 *
 */
	$my_key = serialize($HTTP_POST_VARS).serialize($HTTP_GET_VARS);
	// error_reporting(255);
	include_once('../../include/init.inc');
	$name 		= md5($my_key);
	$filename	= $GLOBALS['DC_ENV']->cachepath.$name.'.lyc';
	$npf_cache = 'no';
	if(file_exists($filename) && empty($npf_cache))
	{
		Header('Content-Length:'.filesize($filename));
		readfile($filename);
		exit();
	}
	else
	{
		includeNaPro('string,array,cache');

		$DC_ENV->layout_chache_id= $my_key;
		$buffer		='';
		$elements	='';

		/**
		* Classe um Variablen und Werte zwischen verschiedenen NPF_Funktione auszutauschen
		*
		* @version 1.1
		* @access public
		*
		*/
		class runtime
		{
			/**
			* @var array $npf_functions
			*/
			var $npf_functions 			= array();

			/**
			* @var array $npf_functions
			*/

			var $npf_def_file			= 'npf_functions.dat';
			/**
			* @var array $env
			*/
			var $env					= array();

			/**
			* @var string $default_inc_location
			*/
			var $default_inc_location	= 'parse';

			function runtime($filename='')
			{
				if (empty($filename)) $filename = $GLOBALS['DC_ENV']->cachepath.'npf_functions.dat';
				$this->npf_def_file = $filename;

				$this->npf_functions = cache_read($this->npf_def_file);
				if (empty($this->npf_functions))
				{
					includeNaPro('na_functions');
					global $DC_ENV;
					naf_generate_def_file($DC_ENV);
					$this->npf_def_file = $GLOBALS['DC_ENV']->cachepath.'npf_functions.dat';
					$this->npf_functions = cache_read($this->npf_def_file);
				}
			}

			/**
			* Bereitet die Parameter für Netautor-Funktionen auf und lädt
			* die entsprechende Funktionsbibliothek nach
			*
			* @param string 	$name	Name der Funktion
			* @param array 	$params	Array mit den 'so-far'-Parametern
			* @param array		$values	Array mit den aktuellen Values
			*
			*/
			function rt_comp_params($name,&$params,&$values)
			{
				if (!isset($this->npf_functions[$name])) return;

				$def = $this->npf_functions[$name];
				$seperators = array();				
				// Wertbehaftete Parameter testen
				if(!empty($def['params']))
				{
					foreach($def['params'] as $param_name => $param_def)
					{							
						if (empty($params[ $param_name.'.seperator' ])) $params[ $param_name.'.seperator' ]=',';
						if ($param_def['flag'])
						{		// Flag-Parameter testen
							if (!isset($params[$param_name]))
							{
								$params[$param_name] = (empty($param_def['default'])?false:true);
							}
							else
							{							
								$params[$param_name] = ( $params[$param_name]=='0' ? false: true );
							}
						}
						else
						{		// Value-Parameter testen
							if (!isset($params[$param_name]) || empty($params[$param_name]))
							{
								$params[$param_name]=$param_def['default'];
								continue;
							}
						}
												
						switch($param_def['magic'])
						{
							case 2: // KEINE ERSETZUNGEN VORNEHMEN
							break;
							case 1: // ERSETZTEN UND ÜBRIGLASSEN
								$params[$param_name]=magicReplacer($params[$param_name],$values,'%',false);
							break;
							case 0:	// ERSETZEN UND DURCH LEERESTRING ERSETZTEN
							default:
								$params[$param_name]=magicReplacer($params[$param_name],$values,'%',true);
							break;
						}
						switch($param_def['quote'])
						{
							case 1: // return normal params not as array
								$params[$param_name]=eval_param($params[$param_name],false,$params[ $param_name.'.seperator' ]);
							break;
							case 2: //return normal params as $params[name][0]
								$params[$param_name]=eval_param($params[$param_name],true,$params[ $param_name.'.seperator' ]);
							break;
						}						
					}
				}
				
				include_once($GLOBALS['DC_ENV']->includepath.'npf_lib/'.basename($def['include']) );
				//include_once($def['include']);
				if (!empty($params['source_tag_name']) && strtolower($params['source_tag_name']) != $name)
				{
					$this->rt_comp_params(strtolower($params['source_tag_name']),$params,$values);
				}
			}

			/**
			* Setzt ein NA-Runtime-Variable
			*
			* @param string $name	Name der Variable
			* @param string $wert	Wert der Variable
			* @access public
			* @return void
			*/
			function rt_set_env($name,$wert)
			{
				$this->env[$name] = $wert;
			}

			/**
			* Setzt ein NA-Runtime-Pointer
			*
			* @param string $name	Name des Pointers
			* @param object $wert	Pointer auf ein Object oder eine Variable
			* @access public
			* @return void
			*/
			function rt_set_pointer($name,&$wert)
			{
				$this->ptr[$name] = &$wert;
			}

			/**
			* Holt ein NA-Runtime-Variable
			*
			* @param 	string $name	Name der Variable
			* @return 	string			Wert oder false
			*/
			function rt_get_env($name)
			{
				if(isset($this->env[$name]))
				{
					return $this->env[$name];
				}
				else
				{
					return false;
				}
			}

			function rt_pipe_values($pipe_filter,&$source)
			{
				if (!is_array($pipe_filter)) $pipe_filter=explode(',',$pipe_filter);
				if (empty($pipe_filter)) return array();
				$result = array();
				reset($pipe_filter);
				foreach ($pipe_filter as $pipe_index => $pipe_name)
				{
					$pipe_name = trim($pipe_name);
					if ($pipe_name=='*')	{	return $source;}

					if (($pos = strpos(strtolower($pipe_name),' as ')))
					{
						$new_pipe_name 	= substr($pipe_name,$pos+4);
						$pipe_name 		= substr($pipe_name,0,$pos);
					}
					else
					{
						$new_pipe_name=$pipe_name;
					}
					if (!empty($pipe_name) && !empty($new_pipe_name))
					{
						if ($new_pipe_name[0]=='&')
						{
							$result[$new_pipe_name]=&$source[$pipe_name];
						}
						else
						{
							$result[$new_pipe_name]=$source[$pipe_name];
						}
					}
				}
				return $result;
			}

			function rt_dependon($condition,&$values)
			{
			}
		}

		/**
		* Erstellt aus einem Array eine schöne Liste mit HTML-Parametern
		*
		* @param array $Params		Array mit den Werten ('name' => 'Wert')
		* @param array $Delimiter	Zeichen für Werte, zb. ' " :
		* @param array $Forbidden	String mit Leerzeichenseparierten Namen die
		* 							in $Params vorkommen aber nicht beachter werden	dürfen
		*
		* @return string			String mit den Parametern
		*/
		function params2list( &$Params, $Delimiter="'", $Forbidden='' )
		{
			$result		='';
			$Forbidden	=' '.strtoupper($Forbidden);

			$trenner = array(	':'	=> array(':'	,';'),
								'"'	=> array('="'	,'"'),
								' '	=> array('= '	,'' ),
								"'" => array("='"	,"'"));
			list($prefix,$postfix) = (!empty($trenner[$Delimiter]) ? $trenner[$Delimiter] : $trenner["'"] );
			$Forbidden = ' '.strtoupper($Forbidden).' ';
			foreach($Params as $name => $Value)
			{
				$name = strtoupper($name);
				if(strpos($Forbidden,' '.$name.' ')>0) continue;
				if (isset($Value))
				{
					if (is_bool($Value))
					{
						if ($Value == true) $result.=' '.$name;
					}
					else
					{
						$result.=' '.$name.$prefix.$Value.$postfix;
					}
				}
				else
				{
					$result.=' '.$name;
				}
			}
			return $result;
		}

	/***********************************************************************
		Prüft, ob ein bestimmter Parameter gesetzt ist oder nicht
		Parameter
			$params		Parameter-Array
			$name		ParameterName
			$Value		Ist $Value leer, so wird nur auf Vorhandensein
						des Parameters getestet, sonst auf diesen Wert
			$DoUnset	Boolean	Flag, ob der Parameter gelöscht werden soll
		Result
			Werte des gewünschten Parameters
	***********************************************************************/
		function evalParam(&$params,$name,$Value='',$DoUnset=true)
		{
			if (!isset($params[$name])) return false;
			if (empty($Value))
			{
				$flag = (empty($params[$name]))?true:$params[$name];
			}
			else
			{
				$flag = (strtolower(trim($params[$name])) == strtolower($Value));
			}
			if ($DoUnset) unset($params[$name]);
			return $flag;
		}
	/***********************************************************************
		?
		Parameter
			$values		Das Array mit den Werten
			$plusminus	Das Array mit möglichen Plus-Minus Anweisungen
			$mode			PLUS oder MINUS ?
			$pre			?
		Result
			?
	***********************************************************************/
		function step_down(&$values,&$plusminus,$mode,&$pre)
		{
			// $pre is needet to extend areas (bereiche) it holds the values without the last key
			if(is_array($plusminus))
			{
				reset		($plusminus);
				$key 		= key	($plusminus);
				$key 		= (empty($key)?'0':$key);
				step_down	($values[$key],$plusminus[$key],$mode,$values);
			}
			else
			{
				if($mode=='plus')
				{
					reset($values);
					// check if the value is a area (breich) or if  it is a multiple field
					if(is_array($values[key($values)]))
					{
						array_push($pre,'');
					}
					else
					{
						array_push($values,'');
					}
				}
				else
				{
					if(is_array($values[key($values)]))
					{
						array_pop($pre);
					}
					else
					{
						array_pop($values);
					//	reset		($values);
					//	end			($values);
					//	$k 		= key($values);
					//	unset		($values[$k]);
					}
				}
			}
		}

		// Wenn keine Layout_id angegeben wird wird hier abgebrochen
		if(empty($mlay_id))
		{		
			if(!empty($mdoc_id) && empty($status))
			{
				$erg= $sql_world->select('SELECT mlayouts.mlay_id FROM mdocs,mlayouts WHERE mdocs.mdoc_id='.$mdoc_id.' AND mdocs.mdoc_mn_naid = mlayouts.mlay_mn_naid AND mlay_default=1',0,1,2);
				if (!empty($erg[0]['mlay_id']))  $mlay_id=$erg[0]['mlay_id'] ;
			}
			if (empty($mlay_id))		
			{
				echo("<html><body bgcolor='white'><br><center><b><font color='Red' size='2' face='Arial'>No layout ID given !</font></b></center></body></html>");
				na_pro_zip(true);
				exit();
			}
		}

		// Layout notfalls übersetzten
		$file = dirname($DC_ENV->installpath).'/layouts/'.$mlay_id.'.lay';
		if (!file_exists($file) || !filesize($file))
		{
			$erg 	= $sql_world->select('SELECT * FROM mlayouts WHERE mlay_id='.$mlay_id,0,1,2);
			if (empty($erg[0]))
			{
				echo("<html><body bgcolor='white' ><br><center><b><font color='Red' size='2' face='Arial'>Layout ID '$mlay_id' not found!</font></b></center></body></html>");
				na_pro_zip(true);
			}

			includeNaPro('nal_compiler');
			$result=nal_create_file($erg[0]);
			if ($result)
			{
			}
			else
			{
				echo("<html><body bgcolor='white'><br><center><b><font color='Red' size='2' face='Arial'>Layout ID '$mlay_id' cannot be compiled ($result)!</font></b></center></body></html>");
				na_pro_zip(true);
			}
		}
		$values 				= parse_post_get_array( '1','xmlval_','1' );
		$values['npf_table'] 	= parse_post_get_array( '1','xmltab_','1' );
		//Create fix für tables Gregor
		//Muß leider vor create und update geschehen im layout ist es zu spät.
		if(!empty($values['npf_table']))
		{
			reset($values);
			$nl="\n";
			while ( list($Key,$Value) = each($values['npf_table']))
			{
				//MAKE SOURCE
				$src	='<!--'.$nl.(serialize($Value)).$nl.'-->'.$nl;
				$params['rows']				=$Value['DEF']['ROWS'];
				$params['cols']				=$Value['DEF']['COLS'];
				$params['table_params']		=$Value['DEF']['TAB_PARAMS'];
				$params['table_name']		=$Value['DEF']['TAB_NAME'];
				$src.='<table '.$params['table_params'].'>'.$nl;
				for($y=0;$y<$params['rows'];$y++)
				{
					$src.='<TR>'.$nl;
					for($x=0;$x<$params['cols'];$x++)
					{
						$src.='<TD class="'.$params['table_name'].'x'.$x.'y'.$y.'">'.$Value['CELL'][$y][$x].'</TD>';
					}
					$src.=$nl;
					$src.='</TR>'.$nl;
				}
				$src.='</table>'.$nl;
				$values[$Key][0]=$src;
				//echo(htmlspecialchars($src));
			}
		}
		$original_values	= $values;


		$commands = array( 	'npf_search'	=>'npf_search'		,'npf_search_x'			=>'npf_search',
							'npf_delete'	=>'npf_delete'		,'npf_delete_x'			=>'npf_delete',
							'npf_update'	=>'npf_update'		,'npf_update_x'			=>'npf_update',
							'npf_update_multi'	=>'npf_update_multi'		,'npf_update_multi_x'			=>'npf_update_multi',
							'npf_create'	=>'npf_create'		,'npf_create_x'			=>'npf_create',
							'npf_cleare'	=>'npf_cleare'		,'npf_cleare_x'			=>'npf_cleare',
							'npf_copy'		=>'npf_copy'		,'npf_copy_x'			=>'npf_copy',
							'status'		=>'status'			,'mdoc_id'				=>'mdoc_id',
							'mlay_id'		=>'mlay_id'			,'params'				=>'params',
							'npf_set_pos'	=>'npf_set_pos'		,'npf_counter'			=>'npf_counter',
							'npf_export'	=>'npf_export'		,'npf_export_x'			=>'npf_export',
							'npf_make_id'	=>'npf_make_id'		,'npf_update_multi_x'	=>'npf_update_multi',
							'npf_perms_users'=>'npf_perms_users','npf_perms_groups'		=>'npf_perms_groups',
							'npf_perms'		=>'npf_perms'		,'npf_restore'			=>'npf_restore',
							'npf_restore_x'	=>'npf_restore'  													);
		foreach($commands as $name => $wert)
		{
			if(isset($$name))	$values[$wert] = $$name;
		}

		// Raufzähler berechnen
		if(!empty($values['plus']))
		{
			foreach ($values['plus'] as $plus_name => $plus_wert)
			{
				step_down($values[$plus_name],$plus_wert,'plus',$values[$plus_name]);
			}
		}

		// Runterzähler berechnen
		if(!empty($values['minus']))
		{
			foreach ($values['minus'] as $minus_name => $minus_wert)
			{
				step_down($values[$minus_name],$minus_wert,'minus',$values[$minus_name]);
			}
		}


		// Laufzeitumgebung initialisiern

		$npf_runtime = new runtime();

		// Nötigenfalls Dokument bearbeiten
		if(	!empty($values['npf_delete']) 		||
			!empty($values['npf_update']) 		||
			!empty($values['npf_create']) 		||
			!empty($values['npf_delete_all']) 	||
			!empty($values['npf_update_multi']) ||
			!empty($values['npf_restore'])
		)
		{
			includeNaPro('mdoc');
			$npf_runtime->rt_set_env('mlay_id',$mlay_id);
			$work_status= mdoc_work($sql_world,$values,$elements,$npf_runtime);
		}

		// Nötigenfalls Dokument einlesen
		unset($mdoc_id);

		if(!empty($values['mdoc_id']) && $values['mdoc_id']>0 && empty($values['status']) )
		{
			includeNaPro('mdoc');

			$erg=mdoc_read( $sql_world, $values['mdoc_id']);

			if (is_array($erg))	$values = array_merge($values,$erg);

			$values['status']='read';
		}

		includeNaPro('db_fields');

//		error_reporting(65535);
// echo($file); exit();
		include_once($file);
		// include($file);

		//echo ('show_lay_'.$mlay_id);
		$to_exec 	= 'show_lay_'.$mlay_id;
		$params		='';
		
		// exit();
		// ini_set('display_error',1);
		// ini_set('display_errors',1);
		// set_time_limit(300);
		// ini_set('memory_limit','128M');
		error_reporting(0);
		$to_exec($params,$values,$elements,$npf_runtime,$GLOBALS['DC_ENV'],$GLOBALS['sql_world']);

		if(empty($npf_cache) || $npf_cache!='no')
		{
			$contents = ob_get_contents();
			ob_end_clean();


			$fp 	= fopen( $filename, 'w' );
			if($fp)
			{
				fwrite( $fp, $contents ,strlen($contents));
				fclose( $fp );
   			}

			echo $contents;
			na_pro_zip(true);
   		}
	}


?>