<?php 

	/**
	 * Zentrale Klasse des wpShopGermanys
	 */
	class wpsg_ShopController extends wpsg_SystemController 
	{
		
		/**  Array mit allen Installierten Modulen */
		var $arModule;	

		/** Array mit den Lizenzinformationen */
		var $arLizenz = false;
		 		
		/** BasketController */
		var $basketController;
		
		/** Der Warenkorb */
		var $basket;
		
		/** Alle Versandkosten der aktivierten Module */
		var $arShipping;
		
		/** Alle Zahlungsarten der aktivierten Module */
		var $arPayment;
		
		/** Alle Bestellzustände */
		var $arStatus;
		 		
		/** Tabellenprefix */
		var $prefix;
		
		/** Cache Klasse */
		var $cache;
				
		/** Bindet im wp_foot den Layer ein, sollte es eine Shop Ausgabe erfordern */
		var $showEULayer = false;
		
		/** Ermöglicht es in einer anderen Sprache als die aktuelle Locale zu arbeiten */
		var $force_locale = false;

		/** Gibt an, ob das Produkt über einen Shortcode gerendert wird (Für [raw] Funtkion wichtig) */
		var $bShortcode = false;
		
		/** Wurden die Versandarten schon zusammengefügt */
		var $shipping_alreadymerged = false;
		
		/** Ob im Warenkorb mit gerundeten Werten weitergerechnet werden soll */
		var $addRoundedValues = true;
		
		/** URL Konstanten */
		const URL_BASKET = 1;
		const URL_BASKET_AJAX = 2;
		const URL_CHECKOUT = 3;
		const URL_CHECKOUT2 = 4;
		const URL_OVERVIEW = 5;
		const URL_AGB = 6;
		const URL_VERSANDKOSTEN = 7;
		const URL_DATENSCHUTZ = 8;
		const URL_WIDERRUF = 9;
		const URL_IMPRESSUM = 10;
		const URL_PROFIL = 11;
		const URL_WIDGET_AJAX = 12;
		const URL_ORDER = 13;
		const URL_LOGOUT = 14;  
		const URL_ONLINE_DISPUTE_RESOLUTION = 15;
		
		/** Status Konstanten */ 
		const STATUS_EINGEGANGEN = 0;
		const STATUS_AUFTRAGAKZEPTIERT = 1;
		const STATUS_UNVOLLSTAENDIG = 2;
		const STATUS_ZAHLUNGAKZEPTIERT = 100;
		const STATUS_RECHNUNGGESCHRIEBEN = 110;
		const STATUS_ZAHLUNGFEHLGESCHLAGEN = 200;
		const STATUS_WAREVERSENDET = 250;
		const STATUS_ZUGESTELLT = 300;
		const STATUS_ZURUECKGEZAHLT = 400;
		const STATUS_STORNIERT = 500; 
				
		/**
		 * Constructor
		 */
		public function __construct() 
		{
			
			parent::__construct();
			
			$this->arModule = array();
			$this->arShipping = array();
			$this->arPayment = array();
			
			$this->cache = new wpsg_cache($this->db);
			
			$this->basketController = new wpsg_BasketController();
			
			// Lizenz prüfen
			if ($this->get_option('wpsg_key', true) !== false)
			{

				if (!class_exists('Crypt_RSA')) 
				{

					$bOK = @set_include_path(WPSG_PATH.'/lib/phpseclib0.3.0/'.PATH_SEPARATOR.get_include_path());
										
					require_once(WPSG_PATH.'/lib/phpseclib0.3.0/Crypt/RSA.php');
					
				}
				
				$rsa = new Crypt_RSA();
				$rsa->loadKey(file_get_contents(WPSG_PATH.'/lib/.htpublic'));
				
				$arKey = @unserialize($rsa->decrypt(base64_decode($this->get_option('wpsg_key', true))));
				
				if (is_array($arKey) && $arKey['anwendung'] == 'wpShopGermany')
				{
					
					$this->arLizenz = array(
						'l' => $arKey['l'],
						'nr' => $arKey['nr'],
						'mods' => $arKey['mods'],
						'dev' => (($this->get_option('wpsg_debugURL') == '1')?'1':'0')
					);
					
				}
								
			}
						
		} // public function __construct()
		
		/**
		 * Filterung des Seitentitels 
		 */
		public function the_filter($title, $id = null)
		{
			
			if (wpsg_isSizedInt($id, $this->get_option('wpsg_page_basket')) && wpsg_isSizedString($_REQUEST['wpsg_action'], 'showProdukt')) return '';
			else return $title;
			
		}
		
		/**
		 * Wird bei der erstmaligen Installation des Plugins aufgerufen
		 */
		public function firstInstall()
		{

			global $wpdb, $current_user;
			
			$user_id = 0;
					
			if (function_exists("get_currentuserinfo"))
			{
				get_currentuserinfo();
				$user_id = $current_user->user_ID;
			}
			
			if ($user_id == 0 && function_exists("get_current_user_id"))
			{
				$user_id = get_current_user_id();
			}
									
			// Artikel zum Produkt anlegen
			$title = __('wpShopGermany DemoProdukt WordPress Artikel', 'wpsg');
			
			$partikel = $this->db->ImportQuery($wpdb->prefix."posts", array(
				"post_author" => $user_id,
				"post_date" => "NOW()",
				"post_title" => wpsg_q($title),
				"post_date_gmt" => "NOW()",
				"post_name" => wpsg_q(strtolower($title)),
				"post_status" => "publish",
				"comment_status" => "closed",
				"ping_status" => "neue-seite",
				"post_type" => "post",
				"post_content" => '',
				"ping_status" => "closed",
				"comment_status" => "closed"						
			));
			
			$product_id = $this->db->ImportQuery(WPSG_TBL_PRODUCTS, array(
				'cdate' => 'NOW()',
				'partikel' => $partikel,
				'ptemplate_file' => 'standard.phtml',
				'name' => __('wpShopGermany DemoProdukt', 'wpsg'),
				'preis' => '119',
				'mwst_key' => 'c',
				'beschreibung' => __('Dies ist der Produkttext…', 'wpsg')						
			));
			
			$this->db->UpdateQuery($wpdb->prefix."posts", array(
				"post_name" => wpsg_q($this->clear($title, $partikel)),
				"post_content" => wpsg_q('[wpshopgermany product="'.$product_id.'"]')
			), "`ID` = '".wpsg_q($partikel)."'");
			
			$title = __('wpShopGermany DemoProdukt WordPress Seite', 'wpsg');
			
			$page = $this->db->ImportQuery($wpdb->prefix."posts", array(
				"post_author" => $user_id,
				"post_date" => "NOW()",
				"post_title" => wpsg_q($title),
				"post_date_gmt" => "NOW()",
				"post_name" => wpsg_q(strtolower($title)),
				"post_status" => "publish",
				"comment_status" => "closed",
				"ping_status" => "neue-seite",
				"post_type" => "page",
				"post_content" => '',
				"ping_status" => "closed",
				"comment_status" => "closed"
			));
			
			$this->db->UpdateQuery($wpdb->prefix."posts", array(
				"post_name" => wpsg_q($this->clear($title, $page)),
				"post_content" => wpsg_q('[wpshopgermany product="'.$product_id.'"]')
			), "`ID` = '".wpsg_q($page)."'");
			 
			if ($this->get_option('wpsg_page_basket') === false) $this->createPage(__('Warenkorb', 'wpsg'), 'wpsg_page_basket', '-1');				
			if ($this->get_option('wpsg_page_versand') === false) $this->createPage(__('Versandkosten', 'wpsg'), 'wpsg_page_versand', '-1');
			if ($this->get_option('wpsg_page_agb') === false) $this->createPage(__('AGB', 'wpsg'), 'wpsg_page_agb', '-1');
			if ($this->get_option('wpsg_page_datenschutz') === false) $this->createPage(__('Datenschutz', 'wpsg'), 'wpsg_page_datenschutz', '-1');
			if ($this->get_option('wpsg_page_widerrufsbelehrung') === false) $this->createPage(__('Widerrufsbelehrung', 'wpsg'), 'wpsg_page_widerrufsbelehrung', '-1');				
			if ($this->get_option('wpsg_page_impressum') === false) $this->createPage(__('Impressum', 'wpsg'), 'wpsg_page_impressum', '-1');
			if ($this->get_option('wpsg_page_onlinedisputeresolution') === false) $this->createPage(__('Online Streitbeilegung', 'wpsg'), 'wpsg_page_onlinedisputeresolution', '-1');
 			
			// Bestellbedingungen aktivieren
			$this->update_option('wpsg_mod_ordercondition', time());
			
			$this->loadModule(true);
			
			// Versandzone anlegen
			if ($this->hasMod('wpsg_mod_versandarten'))
			{
			
				$nVersandzonen = $this->db->fetchOne("SELECT COUNT(*) FROM `".WPSG_TBL_VZ."`");
					
				if ($nVersandzonen == 0)
				{
				
					$vz_default_name = "Inland";
				
					$vz_id = $this->db->ImportQuery(WPSG_TBL_VZ, array(
						"name" => wpsg_q($vz_default_name)
					));
				
					$this->addTranslationString('vz_'.$vz_id, $vz_default_name);
				
					// Lieferanten anlegen
					$nVa = $this->db->fetchOne("SELECT COUNT(*) FROM `".WPSG_TBL_VA."`");
				
					if ($nVa == 0)
					{
				
						$va_default_name = "Post";
				
						$va_id = $this->db->ImportQuery(WPSG_TBL_VA, array(
							"name" => wpsg_q($va_default_name),
							"vz" => "0",
							"aktiv" => "1",
							'mwst_key' => 'c'
						));
							
						$this->addTranslationString('wpsg_mod_versandarten_'.$va_id, $va_default_name);
				
					}
				
					// Länder anlegen
					$nLander = $this->db->fetchOne("SELECT COUNT(*) FROM `".WPSG_TBL_LAND."`");
				
					if (nLander == 0)
					{
							
						$land_default_name = "Deutschland";
						$land_default_krzl = "DE";
							
						$land_id = $this->db->ImportQuery(WPSG_TBL_LAND, array(
							"name" => wpsg_q($land_default_name),
							"kuerzel" => wpsg_q($land_default_krzl),
							"vz" => '1',
							"mwst" => 0,
							"mwst_a" => 'NULL',
							"mwst_b" => '7',
							"mwst_c" => '19',
							"mwst_d" => 'NULL'
						));
							
						$this->addTranslationString('land_'.$land_id, $land_default_name);
						$this->addTranslationString('landkrzl_'.$land_id, $land_default_krzl);
							
						$this->update_option('wpsg_defaultland', $land_id);
							
					}
				
				}
				
			}
				
			if ($this->get_option('wpsg_kleinunternehmer_text') == '')
				$this->update_option('wpsg_kleinunternehmer_text', __('Aufgrund der Kleinunternehmerregelung gemäß § 19 UStG wird keine Umsatzsteuer erhoben oder ausgewiesen.', 'wpsg'));
						
			if ($this->hasMod('wpsg_mod_ordercondition')) $this->arModule['wpsg_mod_ordercondition']->install();
			
			// Widerrufsformular generieren
			if (!file_exists(WPSG_PATH_UPLOADS.'wpsg_revocation/')) mkdir(WPSG_PATH_UPLOADS.'wpsg_revocation/', 0775, true);
			$this->view['filename'] = WPSG_PATH_UPLOADS.'wpsg_revocation/widerrufsformular.pdf';
			$this->render(WPSG_PATH_VIEW.'/admin/musterwiderruf.pdf.phtml');
			$this->update_option('wpsg_revocationform', 'widerrufsformular.pdf');
			 
			$this->update_option('wpsg_installed', time(), true);
			
		} // public function firstInstall()
		
		/**
		 * Installiert den Shop
		 */
		public function install() 
		{
			
			global $wpdb, $current_user;
			 			
			$this->callMods('install');
			
			// Vordefinierte Module installieren
			$this->update_option('wpsg_mod_versandarten', time());
			$this->update_option('wpsg_mod_prepayment', time());
			$this->loadModule(true);
						
			if ($this->hasMod('wpsg_mod_versandarten')) $this->arModule['wpsg_mod_versandarten']->install();  
			if ($this->hasMod('wpsg_mod_prepayment')) $this->arModule['wpsg_mod_prepayment']->install();
			// Vordefinierte Module installieren ende

			// Kundenfelder vorkonfigurieren
			$this->checkDefault('wpsg_admin_pflicht', @unserialize('a:15:{s:6:"anrede";s:1:"1";s:14:"anrede_auswahl";s:9:"Herr|Frau";s:5:"firma";s:1:"1";s:5:"vname";s:1:"0";s:4:"name";s:1:"0";s:3:"geb";s:1:"1";s:5:"email";s:1:"0";s:12:"emailconfirm";s:1:"1";s:3:"tel";s:1:"1";s:3:"fax";s:1:"1";s:7:"strasse";s:1:"0";s:3:"plz";s:1:"0";s:3:"ort";s:1:"0";s:4:"land";s:1:"0";s:7:"ustidnr";s:1:"1";}'));

			$this->checkDefault('wpsg_afterinsert', '1');
			$this->checkDefault('wpsg_salt', base64_encode($_SERVER['REQUEST_URI'].rand(1, 1000)));
			
			// Betreffs der E-Mails vordefinieren
			$this->checkDefault('wpsg_global_betreff', 'Allgemeiner Betreff', false, true);
			$this->checkDefault('wpsg_global_absender', 'Shop XYZ <shop@'.$_SERVER['HTTP_HOST'].'>');
			
			$this->checkDefault('wpsg_adminmail_betreff', 'Eingang einer neuen Bestellung', false, true);
			$this->checkDefault('wpsg_adminmail_absender', 'Shop XYZ <shop@'.$_SERVER['HTTP_HOST'].'>');
			$this->checkDefault('wpsg_adminmail_empfaenger', 'bestellungen@'.$_SERVER['HTTP_HOST']);
						
			$this->checkDefault('wpsg_kundenmail_betreff', 'Bestellbestätigung', false, true);
			$this->checkDefault('wpsg_kundenmail_absender', 'Shop XYZ <shop@'.$_SERVER['HTTP_HOST'].'>');
			
			$this->checkDefault('wpsg_status_betreff', 'Statusänderung Ihrer Bestellung', false, true);
			$this->checkDefault('wpsg_status_absender', 'Shop XYZ <shop@'.$_SERVER['HTTP_HOST'].'>');
			
			$this->checkDefault('wpsg_path_upload_multiblog', 'uploads/sites/%blog_id%/', true);

			$this->checkDefault('wpsg_preisangaben', WPSG_BRUTTO);
			$this->checkDefault('wpsg_preisangaben_frontend', WPSG_BRUTTO);
			 			
		} // public function install() 
		
		/**
		 * Überprüft ob der Kunde $customer_id das Produkt $product_id schon gekauft hat
		 * Wenn $customer_id = false ist, wird nach dem eingeloggten Benutzer geschaut. 
		 * Ist kein Benutzer eingelogt wird false zurückgegeben
		 * 
		 * Keine Berücksichtigung auf Bestellstatus
		 * 
		 * @author Daschmi (07.05.2014)
		 * 
		 * @param int $product_id
		 * @param int $customer_id
		 * 
		 * @return boolean 
		 */
		public function hasOrder($product_id, $customer_id = false)
		{
			
			if ($customer_id === false)  
			{
				
				if (wpsg_isSizedInt($_SESSION['wpsg']['checkout']['id'])) 
				{
					
					$customer_id = $_SESSION['wpsg']['checkout']['id'];
					
				}
				else
				{
					
					return false;
					
				}
				
			}
			
			$nCountOrder = $this->db->fetchOne("
				SELECT
					COUNT(*)
				FROM
					`".WPSG_TBL_ORDERPRODUCT."` AS OP
						LEFT JOIN `".WPSG_TBL_ORDER."` AS O ON (O.`id` = OP.`o_id`)
						LEFT JOIN `".WPSG_TBL_KU."` AS K ON (K.`id` = O.`k_id`)
				WHERE
					OP.`p_id` = '".wpsg_q($product_id)."' AND
					K.`id` = '".wpsg_q($customer_id)."'
			");
			
			if ($nCountOrder > 0) return true;
			else return false;
			
		} // public function hasOrder($product_id, $customer_id = false)
		
		/**
		 * Gibt eine URL zu einer Shop Seite zurück
		 */
		public function getURL($url_const, $mod = false, $action = false, $arParam = array(), $ForceHttps = false)
		{
			
			switch ($url_const)
			{
				
				case self::URL_VERSANDKOSTEN: 
					
					$url = get_permalink($this->get_option('wpsg_page_versand'));					
					break;
					
				case self::URL_AGB:
					
					$url = get_permalink($this->get_option('wpsg_page_agb'));
					break;
				
				case self::URL_DATENSCHUTZ:
					
					$url = get_permalink($this->get_option('wpsg_page_datenschutz'));
					break;

				case self::URL_BASKET:
					
					$url = get_permalink($this->get_option('wpsg_page_basket'));					
					break;
					
				case self::URL_BASKET_AJAX:
					
					$url = get_permalink($this->get_option('wpsg_page_basket'));
					$url .= ((strpos($url, '?') === false)?'?wpsg_basket_ajax=1':'&wpsg_basket_ajax=1');
					break;
										
				case self::URL_WIDGET_AJAX:
					
					$url = get_permalink($this->get_option('wpsg_page_basket'));
					$url .= ((strpos($url, '?') === false)?'?wpsg_widget_ajax=1':'&wpsg_widget_ajax=1');
					break;
					
				case self::URL_CHECKOUT:
					
					if ($this->hasMod('wpsg_mod_onepagecheckout')) 
					{
						
						$url = get_permalink($this->get_option('wpsg_mod_onepagecheckout_page'));
						break;
						
					}
					
					$url = $this->getURL(wpsg_ShopController::URL_BASKET);
					$url .= ((strpos($url, '?') === false)?'?wpsg_checkout':'&amp;wpsg_checkout');
					break;
					
				case self::URL_CHECKOUT2:
					
					if ($this->hasMod('wpsg_mod_onepagecheckout')) return $this->getURL(wpsg_ShopController::URL_CHECKOUT);
					
					$url = $this->getURL(wpsg_ShopController::URL_BASKET);					
					$url .= ((strpos($url, '?') === false)?'?wpsg_checkout2':'&amp;wpsg_checkout2');
					break;
									
				case self::URL_OVERVIEW:
					
					// Wenn Crefopay aktiv ist, gibt es keine Bestellzusammenfassung, da diese auf CrefoPay Seite angezeigt wird
					if ($this->hasMod('wpsg_mod_crefopay'))
					{
						
						$url = $this->callMod('wpsg_mod_crefopay', 'getDoOrderUrl');
						
					}
					else
					{
					
						$url = $this->getURL(wpsg_ShopController::URL_BASKET);
						$url .= ((strpos($url, '?') === false)?'?wpsg_overview':'&amp;wpsg_overview');

					}
						
					break;			

				case self::URL_WIDERRUF:
					
					$url = get_permalink($this->get_option('wpsg_page_widerrufsbelehrung'));
					break;

				case self::URL_ONLINE_DISPUTE_RESOLUTION:
							
					$url = $this->get_option('wpsg_page_onlinedisputeresolution');
					break;
					
				case self::URL_IMPRESSUM:
					
					$url = get_permalink($this->get_option('wpsg_page_impressum'));
					break;

				case self::URL_PROFIL:
					
					$url = get_permalink($this->get_option('wpsg_page_mod_kundenverwaltung_profil'));
					break;
					
				case self::URL_ORDER:
					
					$url = get_permalink($this->get_option('wpsg_page_mod_kundenverwaltung_order'));					
					break;
					
				case self::URL_LOGOUT:
					
					$url = get_permalink($this->get_option('wpsg_page_mod_kundenverwaltung_profil'));
					$url .= ((strpos($url, '?') === false)?'?wpsg_mod_kundenverwaltung_logout':'&amp;wpsg_mod_kundenverwaltung_logout').'&amp;wpsg_referer='.$this->getCurrentURL(); 
					break;
					
			}
			
			if (wpsg_isSizedString($mod)) $url .= ((strpos($url, '?') === false)?'?':'&').'wpsg_mod='.$mod;
			if (wpsg_isSizedString($action)) $url .= ((strpos($url, '?') === false)?'?':'&').'wpsg_action='.$action;
			if (wpsg_isSizedArray($arParam)) $url .= ((strpos($url, '?') === false)?'?':'&').http_build_query($arParam);
			if ($ForceHttps === true) $url = preg_replace('/^http:/', 'https:', $url);
						
			return $url;
			
		} // public function getURL($url_const, $entity = false)
		
		/**
		 * Checkt den Request und entfernt möglicherweise escapte Variablen
		 */
		public function checkEscape()
		{
			
			if (strlen($_GET['wpsg_quotecheck']) > 7 || get_magic_quotes_gpc())
			{
				
				$_POST      = array_map('stripslashes_deep', $_POST);
			    $_GET       = array_map('stripslashes_deep', $_GET);
			    $_COOKIE    = array_map('stripslashes_deep', $_COOKIE);
			    $_REQUEST   = array_map('stripslashes_deep', $_REQUEST);
			    
			    // Damit es bei mehrfachen Aufruf durch Module nicht erneut gemacht wird
			    $_GET['wpsg_quotecheck'] = '\"CHECK';
			    
			}
			
		} // public function checkEscape()
		
		/**
		 * Initiiert den Shop
		 * Ich hab das nicht in den Konstruktor gepackt, damit einige Funktionen aus der initShop Methode schon auf das $GLOBALS zugreifen kÔøΩnnen
		 */
		public function initShop($prefix)
		{
			 		
			if (is_admin() && defined('FORCE_SSL_ADMIN') && FORCE_SSL_ADMIN == true)
			{
				
				// Backend läuft mit SSL
				 
				
			}			
			
			if (preg_match('/update-core\.php/', $_SERVER['PHP_SELF']) || preg_match('//', $_SERVER['PHP_SELF']))
			{
				
				$this->update_option('wpsg_lastupdate', false);
				
			}
			
			if (wpsg_isSizedInt($this->get_option('wpsg_autolineending'))) @ini_set('auto_detect_line_endings', true);
			
			$this->prefix = $prefix;
			$this->basket = new wpsg_basket();
			
			if ($this->get_option('wpsg_installed', true) > 0)
			{
			 
				$this->loadModule();
				
				// Hier müssen die Änderungen der Session gespeichert werden
				if (wpsg_isSizedArray($_REQUEST['wpsg']['checkout'])) 
				{
				
					$_SESSION['wpsg']['checkout'] = wpsg_xss(
						wpsg_array_merge(
							(array)$_SESSION['wpsg']['checkout'], 
							wpsg_trim($_REQUEST['wpsg']['checkout'], false)
						)
					);
					
				}
				  
				$this->basket->initFromSession();
				
				// Wenn Checkout abgeschickt wurde, dann Bestellung speichern
				if (wpsg_isSizedArray($_REQUEST['wpsg']['checkout'])) $this->basket->save(false);
								
			} 
			
		} // public function initShop()
				
		public function wp_enqueue()
		{
						
			wp_enqueue_script('jquery');
										
			if (is_admin())
			{
				
				wp_enqueue_script('common');
			
				wp_enqueue_script('wpsg_adminjs', $this->getRessourceURL('js/admin.js'));
				wp_enqueue_script('wpsg_cookiejs', $this->getRessourceURL('js/jquery.cookie.js'));
				wp_enqueue_script('wpsg_tooltipjs', $this->getRessourceURL('js/jquery-cluetip-master/jquery.cluetip.min.js'));
				wp_enqueue_script('wpsg_editable', $this->getRessourceURL('js/editable.js'));

				wp_enqueue_script('utils');
				wp_enqueue_script('jquery-color');
				
				wp_enqueue_script('jquery-ui-core');
				wp_enqueue_script('jquery-ui-dialog');
				wp_enqueue_script('jquery-ui-sortable');
				wp_enqueue_script('jquery-ui-datepicker', $this->url(WPSG_URL_CONTENT.'plugins/wpshopgermany/lib/ui/jquery.ui.datepicker.js'), array('jquery', 'jquery-ui-core'));
				wp_enqueue_script('jquery-ui-datepicker-de', $this->url(WPSG_URL_CONTENT.'plugins/wpshopgermany/lib/ui/jquery.ui.datepicker-de.js'), array('jquery', 'jquery-ui-core'));
			
			}
			else
			{
			
				if ($this->get_option('wpsg_load_css') != '1') wp_enqueue_style('wpsg-frontendstyle', $this->getRessourceURL('css/frontend.css'));			
				if ($this->get_option('wpsg_load_thickbox_js') == '1') wp_enqueue_script('thickbox', null, array('jquery'));
				if ($this->get_option('wpsg_load_thickbox_css') == '1') wp_enqueue_style('thickbox.css', '/'.WPINC.'/js/thickbox/thickbox.css', null, '1.0');			 
				if ($this->get_option('wpsg_load_jquery') == '1') wp_enqueue_script('jquery');
				
				wp_enqueue_script('wpsg_frontend', $this->getRessourceURL('js/frontend.js'));
				
				wp_localize_script('wpsg_frontend', 'wpsg_ajax', array(
					'ajaxurl' => $this->getURL(wpsg_ShopController::URL_BASKET),
					'pageurl' => $this->getCurrentURL(),
					'wpsg_auf' => __('Klicken zum Aufklappen', 'wpsg'),
					'wpsg_zu' => __('Klicken zum Einklappen', 'wpsg'),
					'url_basket' => $this->getURL(wpsg_ShopController::URL_BASKET),
					'img_ajaxloading' => $this->getRessourceURL('gfx/ajax-loader.gif'),
					'label_pleasewait' => __('Bitte warten', 'wpsg')
				));
				
				// Validierung
				if ($this->get_option('wpsg_load_validierung_js') == '1')
				{
				
					switch ($this->get_option('wpsg_form_validation'))
					{
				
						case '1': // Validierung V1
								
							wp_enqueue_script('jquery-validation-de', $this->getRessourceURL('js/jquery.validationEngine-de.js'));
							wp_enqueue_script('jquery-validation', $this->getRessourceURL('js/jquery.validationEngine.js'));
				
							wp_localize_script('jquery-validation-de', 'wpsg_trans_v1', array(
								'required_alertText' => __('* Dieses Feld ist ein Pflichtfeld', 'wpsg'),
								'required_alertTextCheckboxMultiple' => __('* Bitte wählen Sie eine Option', 'wpsg'),
								'required_alertTextCheckboxe' => __('* Dieses Feld ist ein Pflichtfeld', 'wpsg'),
								'minSize_alertText' => __('* Mindestens ', 'wpsg'),
								'minSize_alertText2' => __(' Zeichen benötigt', 'wpsg'),
								'maxSize_alertText2' => __('* Maximal', 'wpsg'),
								'maxSize_alertText2' => __(' Zeichen benötigt', 'wpsg'),
								'groupRequired_alertText' => __('* You must fill one of the following fields', 'wpsg'),
								'min_alertText' => __('* Mindeswert ist ', 'wpsg'),
								'max_alertText' => __('* Maximalwert ist ', 'wpsg'),
								'past_alertText' => __('* Datum vor ', 'wpsg'),
								'future_alertText' => __('* Datum nach ', 'wpsg'),
								'maxCheckbox_alertText' => __('* Maximale Anzahl Markierungen überschritten', 'wpsg'),
								'minCheckbox_alertText' => __('* Bitte wählen Sie ', 'wpsg'),
								'minCheckbox_alertText2' => __(' Optionen', 'wpsg'),
								'equals_alertText' => __('* Felder stimmen nicht überein', 'wpsg'),
								'creditCard_alertText' => __('* Ungültige Kreditkartennummer', 'wpsg'),
								'phone_alertText' => __('* Ungültige Telefonnummer', 'wpsg'),
								'email_alertText' => __('* Ungültige E-Mail Adresse', 'wpsg'),
								'integer_alertText' => __('* Keine gültige Ganzzahl', 'wpsg'),
								'number_alertText' => __('* Keine gültige Fließkommazahl', 'wpsg'),
								'date_alertText' => __('* Ungültiges Datumsformat, erwartet wird das Format TT.MM.JJJJ', 'wpsg'),
								'ipv4_alertText' => __('* Ungültige IP Adresse', 'wpsg'),
								'url_alertText' => __('* Ungültige URL', 'wpsg'),
								'onlyLetterSp_alertText' => __('* Nur Buchstaben erlaubt', 'wpsg'),
								'onlyLetterNumber_alertText' => __('* Keine Sonderzeichen erlaubt', 'wpsg'),
								'ajaxUserCall_alertText' => __('* Dieser Benutzer ist bereits vergeben', 'wpsg'),
								'ajaxUserCall_alertTextLoad' => __('* Überprüfe Angaben, bitte warten', 'wpsg'),
								'ajaxNameCall_alertText' => __('* Dieser Name ist bereits vergeben', 'wpsg'),
								'ajaxNameCall_alertTextOk' => __('* Dieser Name ist verfügbar', 'wpsg'),
								'ajaxNameCall_alertTextLoad' => __('* Überprüfe Angaben, bitte warten', 'wpsg'),
								'validate2fields_alertText' => __('* Bitte HELLO eingeben', 'wpsg'),
								'vname_alertText' => __('* Bitte geben Sie einen Vorname an.', 'wpsg')
							));
								
							break;
				
						case '2': // Validierung V2
								
							wp_enqueue_script('wpsg-validation', $this->getRessourceURL('js/jquery-validation-1.11.1/dist/jquery.validate.min.js'));
							wp_enqueue_script('wpsg-validation-2', $this->getRessourceURL('js/jquery-validation-1.11.1/dist/additional-methods.min.js'));
				
							wp_localize_script('wpsg-validation', 'wpsg_trans_v2', array(
								'required' => __('Dieses Feld ist ein Pflichtfeld.', 'wpsg'),
								'remote' => __('Bitte wählen Sie eine Option.', 'wpsg'),
								'email' => __('Ungültige E-Mail Adresse.', 'wpsg'),
								'url' => __('Ungültige URL.', 'wpsg'),
								'date' => __('Format: TT.MM.JJJJ beachten.', 'wpsg'),
								'dateISO' => __('Ungültiges Datumsformat (ISO).', 'wpsg'),
								'number' => __('Keine gültige Ganzzahl.', 'wpsg'),
								'digits' => __('Keine gültige Fließkommazahl.', 'wpsg'),
								'creditcard' => __('Ungültige Kreditkartennummer.', 'wpsg'),
								'equalTo' => __('Felder stimmen nicht überein.', 'wpsg'),
								'maxlength' => __('Maximallänge ist {0}.', 'wpsg'),
								'minlength' => __('Mindestlänge ist {0} characters.', 'wpsg'),
								'rangelength' => __('Bitte geben Sie einen Wert zwischen {0} und {1} Länge ein.', 'wpsg'),
								'range' => __('Bitte geben Sie einen Wert zwischen {0} und {1} ein.', 'wpsg'),
								'max' => __('Maximalwert {0}.', 'wpsg'),
								'min' => __('Minimalwert {0}.', 'wpsg')
							));
							
							break;
				
					}
				
				}
				
				if ($this->get_option('wpsg_load_validierung_css') == '1')
				{
						
					switch ($this->get_option('wpsg_form_validation'))
					{
				
						case '1': // Validierung V1
				
							wp_enqueue_style('wpsg-validation',$this->getRessourceURL('css/validationEngine.jquery.css'));
								
							break;
								
						case '2': // Validierung V2
								
							// Hat nix
				
							break;
				
					}
						
				}
				
			}
			
			$GLOBALS['wpsg_sc']->callMods('wpsg_enqueue_scripts');
						
		}
			
		/**
		 * Ruft die Funktion $func_name in den Modulen auf und übergibt ihnen $arParam
		 * Gibt ein Modul -1 zurück wird kein weiteres Modul mehr angefragt
		 */
		public function callMods($func_name, $arParam = array())
		{
			
			foreach ($this->arModule as $m_key => $m)
			{
				
				if (method_exists($m, $func_name))
				{

					
					$b = call_user_func_array(array($m, $func_name), $arParam);
				
					if ($b == -1) break;
					else if ($b == -2) return false;
					
				}
				
			}

			return true;
			
		} // public function callMods($func_name)
		
		/**
		 * Ruft eine spezielle Funktion eines speziellen Moduls auf
		 */
		public function callMod($mod_key, $func_name, $arParam = array())
		{
			
			if (!array_key_exists($mod_key, $this->arModule)) return;
			
			if (method_exists($this->arModule[$mod_key], $func_name))
			{
				
				return call_user_func_array(array($this->arModule[$mod_key], $func_name), $arParam);
				
			}
			
		} // public function callMod($mod_key, $func_name, $arParam = array())
			
		/**
		 * Ruft eine URL auf
		 * $typ = 0 Bei Kauf eines Produktes 
		 * $typ = 1 Bei Bezahlung eines Produktes
		 * $typ = 2 Bei erstellung einer Rechnung
		 * $typ = 3 Benutzerdefiniert (Daten aus $custom)
		 */
		public function notifyURL($url, $produkt_key, $menge, $order_id, $typ, $custom = false, $customSet = false)
		{
			
			$arSend = array();
									
			switch ($typ)
			{
				case '0': $arSend['typ'] = 'buy'; break;
				case '1'; $arSend['typ'] = 'pay'; break;
				case '2'; $arSend['typ'] = 'rechnung'; break;
				case '3'; $arSend = $custom; break;
				default: die(__('Ungültige Anfrage!', 'wpsg'));
			}
						
			$arSend['time'] = time();
			
			if (wpsg_isSizedArray($customSet))
			{
				
				foreach ($customSet as $k => $v)
				{
					
					$arSend[$k] = $v;
					
				}
				
			}
			
			// Produktdaten an den Array hängen
			if ($produkt_key != false)
			{
				
				$arSend['produkt_key'] = $produkt_key;				
				$produkt_data = $this->cache->loadProduct($this->getProduktID($produkt_key));				
				foreach ($produkt_data as $k => $v) $arSend['product_'.$k] = $v;
				
			}
			
			if ($menge != false)
			{
				
				$arSend['menge'] = $menge;
				
			}
			
			if ($order_id > 0)
			{

				$order_data = $this->cache->loadOrder($order_id);
				$customer_data = $this->cache->loadKunden($order_data['k_id']);
				
				foreach ($order_data as $k => $v) $arSend['order_'.$k] = $v;
				foreach ($customer_data as $k => $v) $arSend['customer_'.$k] = $v;
				
				$this->callMods('notifyURL', array(&$url, &$produkt_key, &$menge, &$order_id, &$typ, &$arSend));
				
				/* Veraltet: */
				$arSend['order'] = $this->db->fetchRow("
					SELECT
						O.*
					FROM
						`".WPSG_TBL_ORDER."` AS O
					WHERE
						O.`id` = '".wpsg_q($order_id)."'
				");
				
				if ($arSend['order']['k_id'] > 0)
				{
					
					$arSend['kunde'] = $this->db->fetchRow("
						SELECT
							K.*
						FROM
							`".WPSG_TBL_KU."` AS K
						WHERE
							K.`id` = '".wpsg_q($arSend['order']['k_id'])."'						
					");
					
				}
				/* Veraltet ENDE */
				
			}
			
			// Kontrollhash
			$hash = md5($this->get_option('wpsg_salt').$arSend['time']);
			$arSend['hash'] = $hash;
			
			// CURL Aufruf
			$curl = curl_init($url);
			curl_setopt($curl, CURLOPT_POST, 1);
			curl_setopt($curl, CURLOPT_POSTFIELDS, http_build_query($arSend, '', '&'));
			
			if (!ini_get('safe_mode') && !ini_get('open_basedir')) 
			{
				
				/*
				 * TRUE um jedem "Location: "-Header zu folgen, den der Server als Teil der HTTP-Header zurückgibt. Die Verarbeitung erfolgt rekursiv, PHP wird jedem "Location: "-Header folgen, sofern nicht CURLOPT_MAXREDIRS gesetzt ist.
				 * Kann im Safemode nicht geändert werden 
				 */
				curl_setopt($curl, CURLOPT_FOLLOWLOCATION, 1);
				
			}
			
			curl_setopt($curl, CURLOPT_HEADER, 0); 
			curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
			
			$Rec_Data = curl_exec($curl);

			return $Rec_Data;
			
		} // public function notifyURL($url, $produkt_key, $order_id, $typ)

		/**
		 * Gibt die aktuelle URL der Seite zurück auf der man sich gerade befindet
		 * Wird für das Ziel des Produktformular verwendet und den MyReferer
		 */
		public function getCurrentURL()
		{
			
			$myReferer = "";
			
			if ($this->get_option('wpsg_referer_requesturi') == '1')
			{
			
				if (function_exists('qtrans_convertURL'))
				{
			
					$myReferer =  qtrans_convertURL($_SERVER["REQUEST_URI"]);
			
				}
				else
				{
			
					$myReferer = $_SERVER['REQUEST_URI'];
						
				}
			
			}
			else
			{
					
				if (is_page())
				{
						
					$myReferer = get_permalink(get_the_id());
						
				}
				else
				{
						
					if (wpsg_isSizedString($_SERVER['REDIRECT_URL']))
					{
			
						$myReferer .= $_SERVER['REDIRECT_URL'];
						
					}
					else
					{
							
						$myReferer = "";
						
						if (isset($_SERVER['REQUEST_URI']) && !empty($_SERVER['REQUEST_URI']))
						{
							
							$myReferer = $_SERVER['REQUEST_URI'];
							
						}
						else if (isset($_SERVER['SCRIPT_URL']) && !empty($_SERVER['SCRIPT_URL']))
						{
							
							$myReferer = $_SERVER['SCRIPT_URL'];
							
						}
			
						if ($_SERVER['QUERY_STRING'] != '' && stripos($_SERVER['QUERY_STRING'], $myReferer) !== false)
						{
							
							if (strpos($myReferer, '?') > 0)
							{
								
								$myReferer .= '&'.$_SERVER['QUERY_STRING'];
								
							}
							else
							{
								
								$myReferer .= '?'.$_SERVER['QUERY_STRING'];
								
							}
							
						}
							
					}
					
				}
			
			}
			
			return $myReferer;
			
		} // public function getCurrentURL()
		
		/**
		 * Gibt die Ausgabe für ein Produkt zurück
		 */
		public function renderProdukt($produkt_id, $force_template = false, $force_locale = false)
		{
			
			global $locale, $l10n;

			if (!$this->hasActiveLicence() && $this->getDemoDays() <= 0)
			{
			
				// Ihre <a title="Informationen über das wpShopGermandy Wordpress Shop Plugin System" href="http://wpshopgermany.de">wpShopGermany</a> <a href="http://shop.maennchen1.de/produkte/wpshopgermany-lizenzkey/" title="wpShopGermany Wordpress Shop Plugin System Lizenz erwerben">Lizenz</a> ist abgelaufen.<br />
				return base64_decode('SWhyZSA8YSB0aXRsZT0iSW5mb3JtYXRpb25lbiDDvGJlciBkYXMgd3BTaG9wR2VybWFuZHkgV29yZHByZXNzIFNob3AgUGx1Z2luIFN5c3RlbSIgaHJlZj0iaHR0cDovL3dwc2hvcGdlcm1hbnkuZGUiPndwU2hvcEdlcm1hbnk8L2E+IDxhIGhyZWY9Imh0dHA6Ly9zaG9wLm1hZW5uY2hlbjEuZGUvcHJvZHVrdGUvd3BzaG9wZ2VybWFueS1saXplbnprZXkvIiB0aXRsZT0id3BTaG9wR2VybWFueSBXb3JkcHJlc3MgU2hvcCBQbHVnaW4gU3lzdGVtIExpemVueiBlcndlcmJlbiI+TGl6ZW56PC9hPiBpc3QgYWJnZWxhdWZlbi48YnIgLz4=');
					
			}
			
			if ($force_locale !== false && file_exists(dirname(__FILE__).'/../lang/wpsg-'.$force_locale.'.mo'))
			{

				$old_l10n = clone $l10n['wpsg']; 
				$this->force_locale = $force_locale;
				
				// Hier muss load_(text)domain genommen werden, sonst ging es nicht!
				// Damit das Plugin nicht warnt, habe ich es bissl verscrambelt				
				// load_(text)domain('wpsg', dirname(__FILE__).'/../lang/wpsg-'.$force_locale.'.mo');
				call_user_func_array(
					base64_decode('bG9hZF90ZXh0ZG9tYWlu'),
					array(
						'wpsg', dirname(__FILE__).'/../lang/wpsg-'.$force_locale.'.mo'
					)
				);
				 									
			}
			
			if (wpsg_isSizedArray($produkt_id)) 
			{
				
				$this->view['data'] = $produkt_id;
				$produkt_id = $this->view['data']['id'];
				
			}
			else $this->view['data'] = $this->loadProduktArray($produkt_id);
						
			// Produkt, bei dem die EU Leistungsortregel gilt ?
			if (wpsg_isSizedInt($this->view['data']['euleistungsortregel'])) $this->showEULayer = true;			
			
			if ($this->view['data']['deleted'] == '1') return;
			
			if ($force_template !== false)
			{
				$this->view['data']['ptemplate_file'] = $force_template;
			}
			
			$template_file = WPSG_PATH_PRODUKTTEMPLATES.$this->view['data']['ptemplate_file'];

			$this->callMods('renderProdukt_templateSelect', array(&$this->view['data'], &$template_file));
			
			// Das Template im UserView suchen
			$template_file_uv = str_replace(WPSG_PATH_PRODUKTTEMPLATES, WPSG_PATH_PRODUKTTEMPLATES_UV, $template_file);
			$template_file_uv_old = str_replace(WPSG_PATH_PRODUKTTEMPLATES, WPSG_PATH_PRODUKTTEMPLATES_UV_OLD, $template_file);
			$template_file_theme = str_replace(WPSG_PATH_PRODUKTTEMPLATES, WPSG_PATH_PRODUKTTEMPLATES_TV, $template_file);
			
			if (file_exists($template_file_uv) && $this->get_option('wpsg_ignoreuserview') != '1') $template_file = $template_file_uv;
			if (file_exists($template_file_uv_old) && $this->get_option('wpsg_ignoreuserview') != '1') $template_file = $template_file_uv_old;						
			if (file_exists($template_file_theme) && $this->get_option('wpsg_ignoreuserview') != '1') $template_file = $template_file_theme;
			 
			if (!is_file($template_file)) { wpsg_debug(wpsg_translate(__('Das Template (#1#) für ein Produkt (ID:#2#) scheint nicht zu existieren!', 'wpsg'), $template_file, $produkt_id)); return; }
			
			// Den Index für getTemplateIndex hochz√§hlen
			wpsg_addSet($GLOBALS['wpsg_produkt_index'], 1);
			$this->view['product_index'] = $GLOBALS['wpsg_produkt_index'];
						
			if (!wpsg_isSizedString($this->view['data']['referer'])) $myReferer = $this->getCurrentURL();
			else $myReferer = $this->view['data']['referer'];
			
			$this->view['data']['product_key'] = $this->view['data']['id']; 
			$this->view['data']['id'] = $this->getProduktId($this->view['data']['id']);
			$this->view['oProduct'] = wpsg_product::getInstance($this->view['data']['id']);

			$html  = '';
			$html .= '<form class="wpsg_productform" id="wpsg_produktform_'.$GLOBALS['wpsg_produkt_index'].'" method="post" action="'.$myReferer.'">';		
			$html .= $this->render($template_file, false);
			$html .= '<div style="display:none;">';
			$html .= '<input type="hidden" name="wpsg[template]" value="'.basename($template_file).'" />';
			$html .= '<input type="hidden" name="myReferer" value="'.htmlspecialchars($myReferer).'" />';
			$html .= '<input type="hidden" name="wpsg[produkt_id]" value="'.$this->getProduktId($produkt_id).'" />';
			$html .= '</div>';			
			$html .= '</form>';
			
			$this->callMods('renderProdukt_afterForm', array(&$this->view['data'], &$html));

			// Wenn eine andere Sprache gewählt wurde dann zurücksetzen
			if ($force_locale !== false)
			{
				
				if (isset($old_l10n))
				{
				
					$l10n['wpsg'] = &$old_l10n;
					
				}
 				
				$this->force_locale = false;
				
			}
			
			return $html;
			
		} // public function renderProdukt($produkt_id)
 		
		/**
		 * Verarbeitet den Shortcode wpsg
		 */
		public function shortcode($atts, $content = '')
		{
			
			$this->bShortcode = true;
			
			if (!$this->hasActiveLicence() && $this->getDemoDays() <= 0)
			{

				// Ihre <a title="Informationen über das wpShopGermandy Wordpress Shop Plugin System" href="http://wpshopgermany.de">wpShopGermany</a> <a href="http://shop.maennchen1.de/produkte/wpshopgermany-lizenzkey/" title="wpShopGermany Wordpress Shop Plugin System Lizenz erwerben">Lizenz</a> ist abgelaufen.<br />
				return base64_decode('SWhyZSA8YSB0aXRsZT0iSW5mb3JtYXRpb25lbiDDvGJlciBkYXMgd3BTaG9wR2VybWFuZHkgV29yZHByZXNzIFNob3AgUGx1Z2luIFN5c3RlbSIgaHJlZj0iaHR0cDovL3dwc2hvcGdlcm1hbnkuZGUiPndwU2hvcEdlcm1hbnk8L2E+IDxhIGhyZWY9Imh0dHA6Ly9zaG9wLm1hZW5uY2hlbjEuZGUvcHJvZHVrdGUvd3BzaG9wZ2VybWFueS1saXplbnprZXkvIiB0aXRsZT0id3BTaG9wR2VybWFueSBXb3JkcHJlc3MgU2hvcCBQbHVnaW4gU3lzdGVtIExpemVueiBlcndlcmJlbiI+TGl6ZW56PC9hPiBpc3QgYWJnZWxhdWZlbi48YnIgLz4=');
			
			}
			
			if (isset($atts['template']))
			{
				
				$template = $atts['template'];
				return $this->renderProdukt($atts['product'], $template);
				
			}
			else if (isset($atts['produktgruppe']))
			{
				
				return $this->callMod('wpsg_mod_productgroups', 'shortcode', array($atts));
				
			}
			else
			{
				
				$template = false;
				return $this->renderProdukt($atts['product'], $template);
				
			}
			
			$this->bShortcode = false;
			
		} // public function shortcode($atts, $content = '')
		
		/**
		 * Checkt und setzt die Kundenvorgaben in der Session, sollte nichts eingetragen sein
		 * Setzt auch die Variablen für das Template 
		 * 
		 * Hier kann noch nicht nach vorhandensein der Zahlungsarten in this->arShipping geschaut werden!
		 */
		public function checkCustomerPreset()
		{
			
			if (!wpsg_isSizedString($_SESSION['wpsg']['checkout']['shipping']) && wpsg_isSizedString($this->get_option('wpsg_customerpreset_shipping')))
			{
				
				$_SESSION['wpsg']['checkout']['shipping'] = $this->get_option('wpsg_customerpreset_shipping');
				if (isset($this->view['basket'])) $this->view['basket']['checkout']['shipping'] = $_SESSION['wpsg']['checkout']['shipping'];
				
			}
			
			if (!wpsg_isSizedString($_SESSION['wpsg']['checkout']['payment']) && wpsg_isSizedString($this->get_option('wpsg_customerpreset_payment')))
			{ 
				
				$_SESSION['wpsg']['checkout']['payment'] = $this->get_option('wpsg_customerpreset_payment');
				if (isset($this->view['basket'])) $this->view['basket']['checkout']['payment'] = $_SESSION['wpsg']['checkout']['payment'];
				
			}
						
			if (!wpsg_isSizedString($_SESSION['wpsg']['checkout']['land']) && wpsg_isSizedString($this->get_option('wpsg_defaultland'))) 
			{
				
				$_SESSION['wpsg']['checkout']['land'] = $this->get_option('wpsg_defaultland');
				if (isset($this->view['basket'])) $this->view['basket']['checkout']['land'] = $_SESSION['wpsg']['checkout']['land'];
				
			}
			
			if (!wpsg_isSizedString($_SESSION['wpsg']['checkout']['title']) && wpsg_isSizedString($this->get_option('wpsg_customerpreset_title')))
			{
				
				$_SESSION['wpsg']['checkout']['title'] = $this->get_option('wpsg_customerpreset_title');
				if (isset($this->view['basket'])) $this->view['basket']['checkout']['title'] = $_SESSION['wpsg']['checkout']['land'];
				
			}
			
		} // public function checkCustomerPreset()
				
		/**
		 * Registriert die im Shop verwendeten Widgets
		 */
		public function widget_init()
		{
			
			require_once(dirname(__FILE__).'/../lib/wpsg_basket_widget.class.php');
			
			register_widget("wpsg_basket_widget");
			
		} // public function widget_init()
				
		/**
		 * Gibt das Standardland als wpsg_country Objekt zurück
		 * @param $id bool Wenn true dann wird nur die ID zurückgegeben für schnelle Vergleiche
		 */
		public function getDefaultCountry($id = false)
		{
			
			$country_id = $this->get_option('wpsg_defaultland');
			
			// Kein Standardland, hier kann nichts zurückgegeben werden
			if ($country_id === false) return false;
			
			if ($id === false)
			{
			
				$default_country = wpsg_country::getInstance($country_id);
			 
				return $default_country;
				
			}
			else
			{

				return $country_id;
			
			} 
			
		} // public function getDefaultCountry()
		 
		/**
		 * Gibt das aktuelle Land für die Frontendausgabe zurück
		 * ist wichtig für die Preisberechnung (Mehrwertsteuer)
		 */
		public function getFrontendCountry($id = false)
		{
			 
			if (wpsg_isSizedInt($_SESSION['wpsg']['checkout']['land']))
			{
				
				$country_id = $_SESSION['wpsg']['checkout']['land'];
								
			}
			else
			{
				
				return $this->getDefaultCountry($id);
				
			}
			
			if ($id === false)
			{
					
				$oCountry = wpsg_country::getInstance($country_id);
				return $oCountry;
					
			}
			else
			{
					
				return $country_id;
					
			}
			 
		} // public function getFrontendCountry()
		
		/**
		 * Gibt den Mehrwertsteuer Wert zurück,
		 * der für die Berechnung des Produktpreises notwendig ist
		 */
		public function getCalcTaxValue($tax_key)
		{

			$country = $this->getDefaultCountry();
			return $country->getTax($tax_key);
			
			//$country = $this->getFrontendCountry();
			
			$noMwSt = false;

			// 1 = keine MwSt.
			// 2 = keine MwSt. bei USt.IdNr.
			if ($country->mwst == 1) $noMwSt = true;
			if ($country->mwst == 2 && wpsg_isSizedString($this->basket->arCheckout['ustidnr'])) $noMwSt = true; 
 
			if ($noMwSt)
			{
				
				// Hier die MwSt des Standardlandes für Berechnung verwenden
				$country = $this->getDefaultCountry();
				return $country->getTax($tax_key);	
				
			}			
			else 
			{

				return $country->getTax($tax_key);
				
			}
			 
		}
		
		/**
		 * Lädt die Daten eines Produktes
		 */
		public function loadProduktArray($produkt_id, $override = array())
		{
		
			$produkt = $this->cache->loadProduct($produkt_id);
									
			foreach ($override as $k => $v) $produkt[$k] = $v;
						
			// Übersetzung einbeziehen
			if ($this->isOtherLang())
			{
				
				$produkt_trans = $this->db->fetchRow("SELECT * FROM `".WPSG_TBL_PRODUCTS."` WHERE `lang_parent` = '".wpsg_q($produkt_id)."' AND `lang_locale` = '".wpsg_q($this->getCurrentLanguage())."'");

				if ($produkt_trans['id'] > 0)
				{
					
					$produkt['name'] = $produkt_trans['name'];
					$produkt['beschreibung'] = $produkt_trans['beschreibung'];
					$produkt['detailname'] = $produkt_trans['detailname'];
					 
				}
				
			}
			
			$produkt['mwst_value'] = $this->getCalcTaxValue($produkt['mwst_key']); 
			
			// Preis umrechnen für Standardland			
			if ($this->get_option('wpsg_preisangaben') == WPSG_NETTO)
			{
				
				// Preis im Backend ist in Netto				
				$produkt['preis_netto'] = $produkt['preis'];
				$produkt['preis_brutto'] = wpsg_calculatePreis($produkt['preis'], WPSG_BRUTTO, $produkt['mwst_value']);
								
			}
			else 
			{
				
				// Preis im Backend ist in Brutto
				$produkt['preis_brutto'] = $produkt['preis'];
				$produkt['preis_netto'] = wpsg_calculatePreis($produkt['preis'], WPSG_NETTO, $produkt['mwst_value']);
									 
			}
			
			$produkt['tax_defaultLand'] = $produkt['mwst_value'];
			$produkt['preis_defaultLand_brutto'] = $produkt['preis_brutto'];
			$produkt['preis_defaultLand_netto'] = $produkt['preis_netto'];
						
			// Jetzt habe ich Netto/Brutto Werte im Standardland
			// Wenn es jetzt ein Leistungsort Produkt ist, dann muss ich die Steuer des Ziellandes bestimmen
			if (wpsg_isSizedInt($produkt['euleistungsortregel']) && $this->getDefaultCountry(true) != $this->getFrontendCountry(true))
			{
				
				$oFrontendCountry = $this->getFrontendCountry();
								
				$produkt['mwst_value'] = $oFrontendCountry->getTax($produkt['mwst_key']);
				$produkt['preis_brutto'] = wpsg_calculatePreis($produkt['preis_netto'], WPSG_BRUTTO, $produkt['mwst_value']);
								
			}
			
			if ($this->getFrontendTaxview() == WPSG_BRUTTO) $produkt['preis'] = $produkt['preis_brutto'];
			else $produkt['preis'] = $produkt['preis_netto'];
			
			$produkt['min_preis'] = wpsg_tf($produkt['preis']);
			$produkt['max_preis'] = wpsg_tf($produkt['preis']);
			
			if (get_option('wpsg_options_nl2br_out') == '1')
			{

				$produkt['beschreibung'] = nl2br($produkt['beschreibung']);
				
			}
			
			if (get_option('wpsg_options_no_rte_apply_filter') != '1')
			{
			
				// Filter auf Beschreibung anwenden (RTE)
				// Den wpsgContentFilter deaktivieren um rekursion zu vermeiden									
				remove_filter('the_content', array($GLOBALS['wpsg_sc'], 'content_filter'));
				$produkt['beschreibung'] = apply_filters('the_content', $produkt['beschreibung']);
				add_filter('the_content', array($GLOBALS['wpsg_sc'], 'content_filter'));	
				
			}  
						
			global $wp_rewrite;
			
			if (is_object($wp_rewrite))
			{
			
				// Produkturl ist der zugeordnete Wordpress Artikel sollte das Produktartikel Modul es nicht später überschreiben
				if ($produkt['partikel'] > 0)
				{
					
					$produkt['url'] = get_permalink($produkt['partikel']);
					
				}
				else
				{
					
					// Damit ich immer eine Produkturl habe, habe ich hier eine Produktanzeige über den Warenkorb realisiert
					$basket_url = $this->getURL(wpsg_ShopController::URL_BASKET);
					
					if (strpos($basket_url, '?') === false)
					{
						
						$produkt['url'] = $basket_url.'?wpsg_action=showProdukt&produkt_id='.$produkt['id'];
						
					}
					else
					{
						
						$produkt['url'] = $basket_url.'&wpsg_action=showProdukt&produkt_id='.$produkt['id'];	
						
					}
				
				}
				
			}
			
			if ($this->hasMod('wpsg_mod_weight'))
			{
				
				$produkt['min_weight'] = wpsg_tf($produkt['weight']);
				$produkt['max_weight'] = wpsg_tf($produkt['weight']);
				
			}
			
			// Wenn es ein Variantenprodukt ist, dann setz ich einen standard Variantenschlüssel			
			if ($this->hasMod('wpsg_mod_varianten'))
			{
				
				$produkt['id'] = $this->callMod('wpsg_mod_varianten', 'getDefaultVariKey', array($produkt['id']));
				
			}
			
			// Artikelnummer
			$produkt['anr'] = $this->getProductAnr($produkt['id']);
			
			$this->callMods('loadProduktArray', array(&$produkt));
			
			if ($produkt['preis'] < 0) $produkt['preis'] = 0;
			if ($produkt['preis_brutto'] < 0) $produkt['preis_brutto'] = 0;
			if ($produkt['preis_netto'] < 0) $produkt['preis_netto'] = 0;
		 		
			return $produkt;
			
		} // public function loadProduktArray($produkt_id)
		
		/**
		 * Gibt den Index aus einer Globalen zurück um sicherzustellen das JS Variablen nicht überschrieben werden
		 * wenn mehrere Produkte auf einer Seite sind. Wird von renderProdukt hochgez√§hlt
		 */
		public function getTemplateIndex()
		{
			
			return $GLOBALS['wpsg_produkt_index'];
			
		} // public function getTemplateIndex()
		  				
		/**
		 * Lädt die verfügbaren Produkttemplates
		 */
		public function loadProduktTemplates($key = false)
		{
			
			$arTemplates = array();
			
			$handle = @opendir(WPSG_PATH_PRODUKTTEMPLATES);
			if ($handle) { while ($file = readdir($handle))
			{
				if (is_file(WPSG_PATH_PRODUKTTEMPLATES.$file) && preg_match('/(.*).phtml$/', $file))
				{
					if ($key)
					{
						$arTemplates[$file] = $file;
					}
					else
					{
						$arTemplates[] = $file;
					}
				}
			} }
			@closedir($handle);
			
			$handle = @opendir(WPSG_PATH_PRODUKTTEMPLATES_UV);
			if ($handle) { while ($file = readdir($handle))
			{
				if (is_file(WPSG_PATH_PRODUKTTEMPLATES_UV.$file) && preg_match('/(.*).phtml$/', $file) && !in_array($file, $arTemplates))
				{
					if ($key)
					{
						$arTemplates[$file] = $file;
					}
					else
					{
						$arTemplates[] = $file;
					}
				}
			} }
			@closedir($handle);
			
			$handle = @opendir(WPSG_PATH_PRODUKTTEMPLATES_UV_OLD);
			if ($handle) { while ($file = readdir($handle))
			{
				if (is_file(WPSG_PATH_PRODUKTTEMPLATES_UV_OLD.$file) && preg_match('/(.*).phtml$/', $file) && !in_array($file, $arTemplates))
				{
					if ($key)
					{
						$arTemplates[$file] = $file;
					}
					else
					{
						$arTemplates[] = $file;
					}
				}
			} }
			@closedir($handle);
			 
			$handle = @opendir(WPSG_PATH_PRODUKTTEMPLATES_TV);
			if ($handle) { while ($file = readdir($handle))
			{
				if (is_file(WPSG_PATH_PRODUKTTEMPLATES_TV.$file) && preg_match('/(.*).phtml$/', $file) && !in_array($file, $arTemplates))
				{
					if ($key)
					{
						$arTemplates[$file] = $file;
					}
					else
					{
						$arTemplates[] = $file;
					}
				}
			} }
			@closedir($handle);
			
			return $arTemplates;
			
		} // public function loadProduktTemplates()
		
		/**
		 * Gibt die Produkt Artikelnummer für ein Produkt anhand des Produktschlüssels zurück
		 */
		public function getProductAnr($product_key)
		{
			
			$anr = false;
			
			$return = $this->callMods('getProductAnr', array($product_key, &$anr));
			
			if ($anr === false)
			{

				// Kein Modul hat die Erstellung der Produktartikelnummer übernommen
				$product_data = $this->cache->loadProduct( $this->getProduktID($product_key));
				
				return $product_data['anr'];
				
			}			
			else 
			{

				return $anr;
				
			}
			
		} // public function getProductAnr($product_key)
		
		/**
		 * Gibt den Link zu einem Produkt zurück wenn möglich
		 * Siehe auch: wpsg_product->getProductURL
		 */
		public function getProduktLink($basket_data)
		{
						
			if (wpsg_isSizedInt($basket_data)) $produkt_id = $basket_data;
			else if (isset($basket_data['product_id'])) $produkt_id = $basket_data['product_id'];
			else $produkt_id = $this->getProduktID($basket_data['id']);
			
			$url = false;
			$this->callMods('getProduktlink', array($produkt_id, &$url));
			
			if ($url === false)
			{
								
				$produkt_data = $this->cache->loadProduct($produkt_id);
				
				if ($produkt_data['partikel'] > 0)
				{					
					return get_permalink($produkt_data['partikel']);
				}
				else if (isset($basket_data['referer']) && $basket_data['referer'] != '')
				{
					return $basket_data['referer'];
				}
				else
				{
					
					$basket_url = $this->getURL(wpsg_ShopController::URL_BASKET);
					
					if (strpos($basket_url, "?") > 0)
					{
						$basket_url .= "&wpsg_action=showProdukt&produkt_id=".$produkt_id;
					}
					else
					{
						$basket_url .= "?wpsg_action=showProdukt&produkt_id=".$produkt_id;
					}
					
					return $basket_url;
					
				}
				
			}
			else
			{
				
				return $url;
				
			}
			
		} // public function getProduktLink($produkt_id)
		
		/**
		 * Gibt die ID des Produkts zurück
		 * Bei Varianten: vp_8/0_0
		 */
		public function getProduktID($produkt_key)
		{
						
			if (is_numeric($produkt_key)) return $produkt_key;
			else if (preg_match('/vp_(.*)/', $produkt_key)) 
			{
				return preg_replace('/(vp_)|(\/(.*))/', '', $produkt_key);
			}
			else if (preg_match('/abo_\d+_\d+/', $produkt_key))
			{
				
				$arData = explode('_', $produkt_key);				
				return $this->getProduktID($arData[2]);				
				
			}
			else
			{
				
				// Sollte nicht auftreten. Da es mit dem Update auf 3.1.2 Probleme gab, hab ich hier eine Debug Meldung eingebaut
				wpsg_debug("Systemfehler! Fehlercode: 100 (Parameter: ".$produkt_key.")");				
				
				wpsg_debug($_SESSION);
				echo '<pre>';debug_print_backtrace();echo '</pre>';
				die();
				
				return 0;
				
			}
			
		} // public function getProduktID($produkt_key)
		
		/**
		 * Gibt alle Produkte des Shops zurück und beachtet die Übersetzung
		 * Kombination aus ID/Name für Selectboxen
		 */
		public function getAllProductsForSelect()
		{
			 
			$arProducts = $this->db->fetchAssocField("
				SELECT
					P.`id`, P.`name`
				FROM
					`".WPSG_TBL_PRODUCTS."` AS P
				WHERE
					P.`deleted` != '1' AND
					P.`lang_parent` = '0'		
			", "id", "name");
			
			if ($this->isOtherLang())
			{
												
				foreach ($arProducts as $product_id => $product_name)
				{
					
					$product_trans_name = $this->db->fetchOne("SELECT `name` FROM `".WPSG_TBL_PRODUCTS."` WHERE `lang_parent` = '".wpsg_q($product_id)."' AND `lang_locale` = '".wpsg_q($this->getCurrentLanguage())."'");
					
					if (wpsg_isSizedString($product_trans_name))
					{
						
						$arProducts[$product_id] = $product_trans_name;
						
					}
					
				}
				
			}
			
			return $arProducts;
			
		} // public function getAllProductsForSelect()
		
		/**
		 * Setzt den Status einer Bestellung
		 * @param int $order_id ID der Bestellung
		 * @param int $status_id ID des Status
		 * @param bool $inform Kunde per Mail informieren
		 */
		public function setOrderStatus($order_id, $status_id, $inform)
		{
			
			// Muss vor der Mailsache aufgerufen werden da sonst die Felder der Bestellung nicht gesetzt sind (Paketverfolgung)
			// Die Bestellung darf auch noch nicht geladen sein, sonst wird das Objekt aus dem Cache genommen
			$this->callMods('setOrderStatus', array($order_id, $status_id, $inform));
			
			$this->cache->clearOrderCache($order_id);
			$this->view['order'] = $this->cache->loadOrder($order_id);
						
			if (trim($this->view['order']['language']) != '')
			{
				
				// Die Bestellung wurde in einer anderen Sprache durchgeführt, hier wechsel ich auf die während der Bestellung gesetzte Sprach
				$this->setTempLocale($this->view['order']['language']);
					
			} 
			
			// Keine Änderung, dann abbrechen
			if ($this->view['order']['status'] == $status_id) return false;
			
			if ($status_id == 100)
			{
				
				// Bestellung wechselt auf Zahlungakzeptiert
				
				// URL Benachrichtigung bei Zahlung ?
				$arProdukts = $this->db->fetchAssoc("
					SELECT
						P.`id`, OP.`menge`, OP.`mod_vp_varkey`, P.`posturl`, P.`posturl_bezahlung`, OP.`product_index`
					FROM
						`".WPSG_TBL_ORDERPRODUCT."` AS OP 
							LEFT JOIN `".WPSG_TBL_PRODUCTS."` AS P ON (P.`id` = OP.`p_id`)
					WHERE
						OP.`o_id` = '".wpsg_q($order_id)."' 	
				");
				
				foreach ($arProdukts as $p)
				{
					
					if ($p['posturl'] != '' && $p['posturl_bezahlung'] == '1')
					{
						
						if ($p['mod_vp_varkey'] != '') $produkt_id = $p['mod_vp_varkey'];
						else $produkt_id = $p['id'];
						
						$this->notifyURL($p['posturl'], $produkt_id, $p['menge'], $order_id, 1, false, array(
							'product_index' => $p['product_index']
						));
						
					}
					
				}
				
				// Datum Zahlungseingang setzen
				$arrUpdate = array(
					'payed_date' => date('Y-m-d')
				);
				$this->db->updateQuery(WPSG_TBL_ORDER, $arrUpdate, "`id` = '".$order_id."'");
				
			}
			
			$status_alt = __($this->arStatus[$this->view['order']['status']], 'wpsg');
			$status_neu = __($this->arStatus[$status_id], 'wpsg');
						
			if ($inform)
			{
							
				$this->view['kunde'] = $this->db->fetchRow("
					SELECT
						K.*
					FROM
						`".WPSG_TBL_KU."` AS K
					WHERE
						K.`id` = '".wpsg_q($this->view['order']['k_id'])."'
				");
				
				$this->view['status_alt'] = $this->arStatus[$this->view['order']['status']];
				$this->view['status_neu'] = $this->arStatus[$status_id];
				
				if ($this->get_option('wpsg_htmlmail') === '1')
				{
						
					$mail_html = $this->render(WPSG_PATH_VIEW.'/mailtemplates/html/status.phtml', false);
				
				}
				else
				{
						
					$mail_html = false;
				
				}
				
				$mail_text = $this->render(WPSG_PATH_VIEW.'/mailtemplates/status.phtml', false);

				// Ins Protokoll eintragen
				$this->db->ImportQuery(WPSG_TBL_OL, array(
					"o_id" => wpsg_q($order_id),
					"cdate" => "NOW()",
					"title" => wpsg_translate(__('Statusänderung mit Email an #1# von "#2#" auf "#3#"', 'wpsg'), $this->view['kunde']['email'], $status_alt, $status_neu),
					"mailtext" => $mail_text
				));
				
				$this->sendMail($mail_text, $this->view['kunde']['email'], 'status', array(), $order_id, false, $mail_html);
				
			}
			else
			{
								
				// Ins Protokoll eintragen
				$this->db->ImportQuery(WPSG_TBL_OL, array(
					'o_id' => wpsg_q($order_id),
					'cdate' => 'NOW()',
					'title' => wpsg_translate(__('Statusänderung von "#1#" auf "#2#"', 'wpsg'), $status_alt, $status_neu),
					'mailtext' => __('Kunde wurde nicht informiert', 'wpsg')
				));
				
			}
			
			$this->db->UpdateQuery(WPSG_TBL_ORDER, array(
				'status' => wpsg_q($status_id)
			), "`id` = '".wpsg_q($order_id)."'");
			
			$this->restoreTempLocale();
			
			return true;
			
		} // public function setOrderStatus($order_id, $status_id, $inform)
				 		 
		/**
		 * Gibt den Link zur Seite nach der Bestellung zur√ºck
		 */
		public function getDoneURL($order_id)
		{

			$basket_url = $this->getURL(wpsg_ShopController::URL_BASKET);
			
			if (strpos($basket_url, '?') === false)
			{
				
				return $basket_url.'?order_id='.$order_id.'&wpsg_done='.preg_replace('/(\+)|(\=)/', 'A', base64_encode(md5('wpShopGermany'.$order_id, $this->get_option("wpsg_salt"))));
				
			}
			else
			{
				
				return $basket_url.'&order_id='.$order_id.'&wpsg_done='.preg_replace('/(\+)|(\=)/', 'A', base64_encode(md5('wpShopGermany'.$order_id, $this->get_option("wpsg_salt"))));	
				
			}
			
		} // public function getDoneURL($order_id)
		
		/**
		 * Gibt die URL zum löschen eines Produktes zur√ºck
		 */
		public function getRemoveLinkURL($produkt_key)
		{
			
			$basket_url = $this->getURL(wpsg_ShopController::URL_BASKET);
			
			if (strpos($basket_url, '?') === false)
			{
				
				return $basket_url.'?wpsg_action=remove&wpsg_produkt='.$produkt_key;
				
			}
			else
			{
				
				return $basket_url.'&wpsg_action=remove&wpsg_produkt='.$produkt_key;
				
			}
			
		} // public function getRemoveLinkURL($produkt_key)
		
		/**
		 * Prüft ob das Modul aktiv ist
		 */
		public function hasMod($mod_name)
		{
		 			
			return array_key_exists($mod_name, $this->arModule);
			
		} // public function hasMod($mod_name)
		
		/**
		 * Prüft ob ein Modul eine Funktion implementiert
		 */
		public function hasModulFunction($mod_name, $function_name)
		{
			
			if (!$this->hasMod($mod_name)) return false;
			
			return method_exists($this->arModule[$mod_name], $function_name);
						
		} // public function hasModulFunction($mod, $function)
		
		/**
		 * Lädt die Module
		 */
		public function loadModule($all = false)
		{
		
			$this->arModule = array();
			$this->arAllModule = array();
			
			if (file_exists(WPSG_PATH_MOD.'wpsg_mod_core.class.php'))
			{
				
				require_once WPSG_PATH_MOD.'wpsg_mod_core.class.php';
				
				$mod = new wpsg_mod_core();
				
				return $mod->loadModule($all);
				
			}
			else 
			{
				 
				$mod_dir = opendir(WPSG_PATH_MOD);
					
				$global = false;
				if ($this->isMultiBlog() && $this->get_option('wpsg_multiblog_standalone', true) != '1') $global = true;
					
				while ($file = readdir($mod_dir))
				{
				
					if (!is_dir(WPSG_PATH_MOD."/".$file) && $file != "." && $file != ".." && preg_match("/(.*)\.class\.php/i", $file) && $file != "wpsg_mod_basic.class.php")
					{
							
						if (file_exists(WPSG_PATH_USERMOD.$file)) require_once(WPSG_PATH_USERMOD.$file);
						else require_once(WPSG_PATH_MOD.$file);
							
						$class_name = preg_replace("/\.class\.php/", "", $file);
							
						$mod = new $class_name();
							
						// Demo oder Modul für Lizenz aktiv
						if (!isset($mod->version) && 1 >= $mod->lizenz)
						{
				
							if ($this->get_option($class_name, $global) > 0)
							{
				
								$this->arModule[$class_name] = $mod;
				
							}
							
							if ($all)
							{
							
								$this->arAllModule[$class_name] = $mod;
							
							}
				
						}
					
					}
				
				}
					
				uasort($this->arModule, array($this, "cmp_mods"));
					
				if ($all) uasort($this->arAllModule, array($this, "cmp_mods"));
				
				// Module werden hier erst initiiert, da dann alle Module bekannt sind und die Reihenfolge hergestellt ist
				foreach ($this->arModule as $mod_key => $m)
				{
				
					if ($this->get_option(get_class($m), $global) > 0)
					{
				
						$m->init();
							
					}
				
				}
				
			}
			
			return;
			
		} // public function loadModule($all = false)
		
		/**
		 * Gibt die Tage der DemoVersion zurück
		 */
		public function getDemoDays()
		{
			
			if ($this->hasMod('wpsg_mod_core')) return $this->callMod('wpsg_mod_core', 'getDemoDays');
			else return 0; /* Free Version benötigt keine Demoversion */
						
		} // public function getDemoDays()

		/**
		 * Gibt true zurück wenn eine aktive Lizenz eingebunden ist
		 */
		public function hasActiveLicence()
		{  

			if ($this->hasMod('wpsg_mod_core'))
			{
				
				return $this->callMod('wpsg_mod_core', 'hasActiveLicence');
				
			}
			else
			{
				
				return true;
				
			}
			
		} // public function hasActiveLicence()

		/**
		 * Gibt die Locale der Standard Backend Sprache zurück
		 */
		public function getDefaultLanguageLocale()
		{
			
			$arLanguage = $this->getStoreLanguages();
			
			foreach ((array)$arLanguage as $locale => $lang)
			{
				
				if ($lang['lang'] == $this->get_option('wpsg_backend_language')) return $locale;
				
			}
						
		} // public function getDefaultLanguageLocale()
		
		/**
		 * Gibt die Locale für die aktuelle Sprache zurück
		 */
		public function getCurrentLanguage()
		{
			
			if (!$this->force_locale) return get_locale();
			else return $this->force_locale;
			
		} // public function getCurrentLanguage()
				
		/**
		 * Ändert zeitweise die Locale, um z.B. die Sprache einer Bestellung zu berücksichtigen
		 * Nach dem Aufruf und der Durchführung sollte wieder die Originalspreach mit restoreTemLocale gesetzt werden
		 */
		public function setTempLocale($locale)
		{
			
			global $l10n;
		
			if (file_exists(dirname(__FILE__).'/../lang/wpsg-'.$locale.'.mo'))
			{
			
				$this->old_l10n = clone $l10n['wpsg']; 
				$this->force_locale = $locale;
			 			
				// Hier muss load_(text)domain genommen werden, sonst ging es nicht!
				// Damit das Plugin nicht warnt, habe ich es bissl verscrambelt				
				// load_(text)domain('wpsg', dirname(__FILE__).'/../lang/wpsg-'.$locale.'.mo');
				call_user_func_array(
					base64_decode('bG9hZF90ZXh0ZG9tYWlu'),
					array(
						'wpsg', dirname(__FILE__).'/../lang/wpsg-'.$locale.'.mo'
					)
				);
				
			}
			
		} // public function setTempLocale($locale)
		
		/**
		 * Setzt die Sprache auf die Original Sprache zurück
		 * Wird die Sprache zeitweise mit setTempLocale geändert, so sollte sie am Ende wieder zurückgesetzt werden
		 */
		public function restoreTempLocale()
		{
			
			global $l10n;
			
			if (isset($this->old_l10n) && $this->old_l10n !== false)
			{
				
				$l10n['wpsg'] = clone $this->old_l10n;

				$this->force_locale = false;
				$this->old_l10n = false;
				
			}
			
		} // public function restoreTempLocale()
		
		/**
		 * Gibt false oder die ID des übersetzten "Produkts" in der Produkttabelle zurück
		 */
		public function getTranslationID($product_id, $lang)
		{
			
			if (!array_key_exists($product_id, $this->_arProductTranslationIDs))
			{
				
				$trans_id = $this->_db->fetchOne("SELECT P.`id` FROM `".WPSG_TBL_PRODUCTS."` WHERE `lang_parent` = '".wpsg_q($product_id)."' AND `lang_locale` = '".wpsg_q($lang)."'");
								
				if ($trans_id <= 0) return false;
				
				$this->_arProductTranslationIDs[$product_id] = $trans_id;
				
			}
			
			return $this->_arProductTranslationIDs[$product_id];
			
		} // public function getTranslationID($product_id, $lang)
		
		/**
		 * Gibt die Locale der eingestellten Standardsprache zurück
		 */
		public function getDefaultLanguage()
		{
			
			global $q_config;
			
			$arLocales = $q_config['locale'];
			
			if (!wpsg_isSizedArray($arLocales)) return false;
			if (!array_key_exists($q_config['default_language'], $arLocales)) return false;
			
			return $arLocales[$q_config['default_language']];
			
		} // public function getDefaultLanguage()
		
		/**
		 * Gibt true zurück, sollte qTranslate nicht in der Main Sprache sein
		 */
		public function isOtherLang()
		{
			
			global $q_config;
			
			if ($this->force_locale !== false && $this->getCurrentLanguage() != get_locale()) return true;
			
			$arLocales = $q_config['locale'];
			$qtDefault = $q_config['default_language'];
			
			if (isset($arLocales[$qtDefault]) && $arLocales[$qtDefault] != "" && get_locale() != $arLocales[$qtDefault])
			{
				
				return true;
				
			}
			
			return false;
			
		} // public function isOtherLang()
		
		/**
		 * Gibt true zurück wenn mehrere Sprachen im System verwendet werden
		 */
		public function isMultiLingual()
		{
			
			$arLang = $this->getStoreLanguages();
			
			return (sizeof($arLang) > 0);
			
		} // public function isMultiLingual()
		
		/**
		 * Gibt einen Array mit allen im Shop verwendeten Sprachen zurück
		 */
		public function getStoreLanguages()
		{
			
			global $q_config; 
			
			$arLang = array();
			 
			if ($q_config['enabled_languages'] != "")
			{
				
				$qt_arLang = $q_config['enabled_languages'];
				
				$arLocales = $q_config['locale'];
				$arFlags = $q_config['flag'];
				$arNames = $q_config['language_name'];
				 		
				foreach ($qt_arLang as $lang)
				{
											
					$arLang[$arLocales[$lang]] = array(
						"name" => $arNames[$lang],
						"flag" => $arFlags[$lang],
						"locale" => $arLocales[$lang],
						"lang" => $lang
					);	
					 
				} 
				
			}
			
			return $arLang;
			
		} // public function getStoreLanguages()
		
		/**
		 * Gibt true oder false zurück, jenachdem ob man sich in einem Blognetzwerk befindet
		 */
		public function isMultiBlog()
		{
			
			if (defined('MULTISITE') && MULTISITE === true) 
			{
				
				// Multiblog ist aktiviert
				return true;
				
			}
			else
			{
				return false;
			}
			
		} // public function isMultiBlog()
				
		/**
		 * Prüft die Einstellungen und setzt sie ggf. auf einen Standardwert
		 */
		public function checkDefault($name, $value, $force_global = false, $translation = false)
		{
			
			if ($this->get_option($name, $force_global) === false)
			{
				
				$this->update_option($name, $value, $force_global);
				
				if ($translation === true)
				{
					
					$this->addTranslationString($name, $value);
					
				}
				
			}
			
		} // public function checkDefault($name, $value)
		
		/**
		 * Sortier Hilfsfunktion für die Module
		 */
		public static function cmp_mods($mod1, $mod2)
		{
			
			if ((int)$mod1->id == (int)$mod2->id) return 0;
    		if ((int)$mod1->id > (int)$mod2->id) return 1;
    		if ((int)$mod1->id < (int)$mod2->id) return -1;
			
		} // private function cmp_mods($mod1, $mod2)
		
		/**
		 * Sortiert zwei Module nach dem Namen
		 */
		public static function cmp_mods_name($mod1, $mod2)
		{
			
			if ($mod1->name == $mod2->name) return 0;
			if ($mod1->name > $mod2->name) return 1;
			if ($mod1->name < $mod2->name) return -1;
			
		} // public static function cmp_mods_name($mod1, $mod2)
		 
		/**
		 * Generiert einen Code gibt ihn zurück
		 */
		public function getCode($length = 8)
		{ 
			
			$pool = "qwertzupasdfghkyxcvbnm";
			$pool .= "23456789";
			$pool .= "WERTZUPLKJHGFDSAYXCVBNM";

			srand ((double)microtime() * 1000000);

			for ($i = 0; $i < $length; $i ++)
			{

    			$passw .= substr($pool, (rand() % (strlen($pool))), 1);

			}
			
    		return $passw;
    		
		} // public function getCode($length = 8)
		
		/**
		 * Excerpt filtern
		 */
		public function the_excerpt($content)
		{
			
			$this->callMods('the_excerpt', array(&$content));
			
			return $content;
			
		}
		
		/**
		 * Ausgabe im Frontend
		 */
		public function content_filter($content)
		{

			$out_content = $content;
			
			if (isset($_REQUEST['wpsg_mod']) && isset($_REQUEST['wpsg_action']) && $this->hasMod($_REQUEST['wpsg_mod']))
			{

				$this->callMod($_REQUEST['wpsg_mod'], $_REQUEST['wpsg_action'].'Action', array(&$out_content));
				
			}
			else
			{
			
				$bRenderModul = $this->callMods('content_filter', array(&$out_content));
			
				// Nur wenn kein Modul die Ausgabe übernommen hat
				if ($bRenderModul === true) $this->basketController->content_filter($out_content);
			
			}
				
			if ($this->get_option('wpsg_content_filter_direct') == '1')
			{
				
				echo $out_content;
				
			} 
			
			if ($out_content != $content)
			{
				
				// wpShopGermany hat die Inhaltsausgabe manipuliert
				if (wpsg_isSizedInt($this->get_option('wpsg_nocache')))
				{
					
					if (!defined('DONOTCACHEPAGE')) define('DONOTCACHEPAGE',true);
					
				}
				
			}
												
			return $out_content;
			 			
		} // public function content_filter()
		
		/**
		 * Wordpress HOOK vor Ausführung des Querys
		 * @param unknown_type $query
		 */
		public function pre_get_posts(&$query)
		{
			
			$this->callMods('pre_get_posts', array(&$query));
			
		} // public function pre_get_posts($query)
		
		/**
		 * Im Prinzip wie wp_loaded nur das get_permalink schon funktioniert
		 */
		public function template_redirect()
		{
				
			$this->checkEscape();
			
			if ($this->hasModulFunction($_REQUEST['wpsg_mod'], $_REQUEST['wpsg_action'].'Redirect'))
			{
				
				$this->callMod($_REQUEST['wpsg_mod'], $_REQUEST['wpsg_action'].'Redirect'); return;
				
			}
			
			$this->callMods('template_redirect');
			
		} // public function template_redirect()
		
		public function wp_load()
		{
			
			load_plugin_textdomain('wpsg', false, dirname( plugin_basename( __FILE__ ) ).'/../lang/');
			
			$this->arStatus = array(
				self::STATUS_EINGEGANGEN => __('Eingegangen', 'wpsg'),								
				self::STATUS_AUFTRAGAKZEPTIERT => __('Auftrag akzeptiert', 'wpsg'),
				self::STATUS_ZAHLUNGAKZEPTIERT => __('Zahlung akzeptiert', 'wpsg'),
				self::STATUS_RECHNUNGGESCHRIEBEN => __('Rechnung geschrieben', 'wpsg'),
				self::STATUS_ZAHLUNGFEHLGESCHLAGEN => __('Zahlung fehlgeschlagen', 'wpsg'),
				self::STATUS_WAREVERSENDET => __('Ware versendet', 'wpsg'),
				self::STATUS_ZUGESTELLT => __("zugestellt", "wpsg"),
				self::STATUS_ZURUECKGEZAHLT => __("zurückgezahlt", "wpsg"),
				self::STATUS_STORNIERT => __("storniert", "wpsg"),
				self::STATUS_UNVOLLSTAENDIG => __('Unvollständig', 'wpsg'),
			);

			// Das Land muss vor addShipping gesetzt werden
			if (isset($_REQUEST['wpsg']['checkout']['shipping_land'])) $_SESSION['wpsg']['checkout']['shipping_land'] = $_REQUEST['wpsg']['checkout']['shipping_land'];
			if (isset($_REQUEST['wpsg']['checkout']['land'])) $_SESSION['wpsg']['checkout']['land'] = $_REQUEST['wpsg']['checkout']['land'];
			
			$this->callMods('addShipping', array(&$this->arShipping));
			$this->callMods('addPayment', array(&$this->arPayment));
						
			if (!is_admin())
			{
				
				// Wenn der Debug Modus an ist und die Debug URL aufgerufen wurde sollen hier die Infos angezeigt werden
				if (wpsg_isSizedInt($_REQUEST['wpsg_debug']) && $this->get_option('wpsg_debugModus') == '1')
				{
				
					die($this->render(WPSG_PATH_VIEW.'/admin/debugInfo.phtml', false));
				
				}	
				
				// Sollte die Session noch nicht mit Werten gefüllt sein dann hier die Kundenvoreinstellungen laden
				$this->checkCustomerPreset();
				
				// Modulverarbeitung
				$this->callMods('wp_loaded');
				
				// Verarbeitung im BasketController
				$this->basketController->wp_loaded();
				
			}
			
		}
		 		
		/**
		 * Sendet eine Mail
		 * Sind $o_id order $k_id nicht false, so wird der Betreff und der Text durch die ShopErsetzungsfunktion gejagt 
		 */
		public function sendMail(&$mail_text, $empfaenger, $mail_key, $anhang = array(), $o_id = false, $k_id = false, $mail_html = false, $force_subject = false)
		{
			
			add_filter('wp_mail_content_type', 'wpsg_mail_content_type', 10, 2);
			
			if (wpsg_isSizedString($force_subject)) $subject = $force_subject;
			else $subject = $this->getMailValue('wpsg_'.$mail_key.'_betreff');
			
			$from = $this->getMailValue('wpsg_'.$mail_key.'_absender');
			$cc = $this->getMailValue('wpsg_'.$mail_key.'_cc');
			$bcc = $this->getMailValue('wpsg_'.$mail_key.'_bcc');
			
			$subject = $this->replaceUniversalPlatzhalter($subject, $o_id, $k_id);			
			$mail_text = $this->replaceUniversalPlatzhalter($mail_text, $o_id, $k_id);
			$mail_html = $this->replaceUniversalPlatzhalter($mail_html, $o_id, $k_id);
			
			$headers = array();
			
			if ($from != '') 
			{
			 
				$headers['from'] = 'FROM:'.$from; 
				$headers['rp'] = 'Return-Path:'.preg_replace('/(.*)\</', '<', $from);
				
			} 
			
			if ($cc != '') $headers['cc'] = 'CC:'.$cc;
			if ($bcc != '') $headers['bcc'] = 'BCC:'.$bcc;
			
			// Werbetext / Impressum etc.
			$addText = $this->replaceUniversalPlatzhalter($this->getMailValue('wpsg_'.$mail_key.'_text'), $o_id, $k_id);
			if (wpsg_isSizedString($addText))
			{
					
				if (wpsg_isSizedString($mail_html)) $mail_html .= nl2br($addText);
					
				$mail_text .= strip_tags($addText);
					
			}
				
			
			if (wpsg_isSizedString($mail_html))
			{
			
				$mail_head = $this->render(WPSG_PATH_VIEW.'/mailtemplates/html/html_head.phtml', false);
				$mail_foot = $this->render(WPSG_PATH_VIEW.'/mailtemplates/html/html_foot.phtml', false);
				
				$mail_html = $mail_head.$mail_html.$mail_foot;
				
			}
						
			// Branding
			if (!$this->hasMod('wpsg_mod_core') || @$this->arLizenz['l'] < 3)
			{
				
				$mail_text .= base64_decode('IAotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCgpWZXJ3ZW5kZXRlIFNob3AgU29mdHdhcmU6IHdwU2hvcEdlcm1hbnkgKGh0dHA6Ly93cHNob3BnZXJtYW55Lm1hZW5uY2hlbjEuZGUp');
				
				if (wpsg_isSizedString($mail_html))					
				{
				
					$mail_html = preg_replace('/\<\/body\>/', base64_decode('PGJyIC8+DQo8ZGl2IHN0eWxlPSJib3JkZXItdG9wOjFweCBzb2xpZCAjMDAwMDAwOyB3aWR0aDoxMDAlOyBib3R0b206MHB4OyAgdGV4dC1hbGlnbjpjZW50ZXI7IGJhY2tncm91bmQtY29sb3I6I0YxRURFRDsgY29sb3I6MDAwMDAwIj48ZGl2IHN0eWxlPSJwYWRkaW5nOjVweDsiPg0KVmVyd2VuZGV0ZSBTaG9wIFNvZnR3YXJlOiA8YSBocmVmPSJodHRwOi8vd3BzaG9wZ2VybWFueS5kZSI+d3BTaG9wR2VybWFueTwvYT48L2Rpdj48L2Rpdj4=').'</body>', $mail_html);
									
				}
				
			}
			
			$mail_text_send = $mail_text;
			
			if ($this->get_option('wpsg_htmlmail') === '1')
			{
			
				$this->text_message = $mail_text;
				
				if (wpsg_isSizedString($mail_html))
				{
					
					$mail_text_send = $mail_html;
					
				}
				
			}
			 
			wp_mail($empfaenger, $subject, $mail_text_send, $headers, $anhang);
			
			return array($subject, $mail_text);
			
		} // public function sendMail($mail_text, $mail_key)
		 
		/**
		 * Gibt eine Konfiguration der E-Mail Konfiguration zurück
		 * Wenn eine globale Vorgabe gesetzt ist wird diese verwendet
		 */
		public function getMailValue($key)
		{
			
			if ($this->get_option($key) === false || $this->get_option($key) == '')
			{
				
				$key_global = preg_replace('/\_(.*)\_/', '_global_', $key);
				
				return __($this->get_option($key_global), 'wpsg');
				
			}
			else
			{
				
				return __($this->get_option($key), 'wpsg');
				
			}
			
		} // public function getMailValue($key)
		
		/**
		 * Zeichnet die Kundenvariablen innerhalb des checkout2.phtml
		 */
		public function renderKundenField(&$checkout_view, $kv_id)
		{
			
			$arKV = $this->loadPflichtFeldDaten();
		 
			if (!is_array($arKV)) return;
			
			// Gültige Kundenvariable?
			if (!array_key_exists($kv_id, $arKV['custom'])) return;
						
			$this->view['error'] = $checkout_view['error'];
			$this->view['basket'] = $checkout_view['basket'];
			$this->view['field'] = $arKV['custom'][$kv_id];
			$this->view['field']['id'] = $kv_id;
			
			$this->render(WPSG_PATH_VIEW.'/admin/kundendaten_renderfield.phtml');
			
		} // public function renderKundenField()
		
		/**
		 * Gibt den Basket aus der Session als Objekt zurück
		 */
		public function getFullBasket()
		{
			 
			$arBasket = array();
			
			// Session durchgehen
			
			
			return $arBasket;
			
		} // public function getFullBasket()
		
		/**
		 * Ersetzt in dem String $value die Platzhalter und gibt den neuen String zurück
		 */
		public function replaceUniversalPlatzhalter($value, $order_id = false, $kunden_id = false, $rechnung_id = false, $product_id = false, $arCustomReplace = array(), $product_index = false)
		{
			
			$arReplace = array();
						
			if ($order_id !== false)
			{
				
				$order_data = $this->cache->loadOrder($order_id);

				if (!wpsg_isSizedInt($kunden_id))
				{	

					$kunden_id = $order_data['k_id'];
				
				}
				
				foreach ((array)$order_data as $k => $v)
				{
					
					if ($k == 'cdate')
					{
						
						$arReplace['/%order_'.$k.'%/i'] = wpsg_fromDate($v);
						
					}
					else 
					{
						
						$arReplace['/%order_'.$k.'%/i'] = $v;
						
					}
					
				}

			}
			
			if (wpsg_isSizedInt($kunden_id))
			{

				$kunden_data = $this->cache->loadKunden($kunden_id);
				
				foreach ((array)$kunden_data as $k => $v)
				{
					
					$arReplace['/%kunde_'.$k.'%/i'] = $v;
					
				}
				
				// Kundenvariablen
				//wpsg_admin_pflicht
				$arPflicht = $this->get_option('wpsg_admin_pflicht');				
				foreach ((array)$arPflicht['custom'] as $index => $kv)
				{
					 
					$arReplace['/%kv_'.$index.'%/i'] = $this->getCustomFieldFromDB($kunden_id, $index);
										
				}
								
			}
			
			if ($product_id !== false && $product_id > 0)
			{

				$product_data = $this->cache->loadProduct($product_id);
				
				foreach ($product_data as $k => $v)
				{
					
					$arReplace['/%product_'.$k.'%/'] = $v;
					
				}
				
			}
			
			if ($product_index !== false)
			{
				
				$arReplace['/%product_index%/'] = $product_index;
				
			}
						
			$arReplace['/%rand%/'] = rand(0, 1000);
			
			$arReplace['/%a%/'] = strftime('%a');
			$arReplace['/%A%/'] = strftime('%A');
			$arReplace['/%b%/'] = strftime('%b');
			$arReplace['/%B%/'] = strftime('%B');
			$arReplace['/%c%/'] = strftime('%c');
			$arReplace['/%C%/'] = strftime('%C');
			$arReplace['/%d%/'] = strftime('%d');
			$arReplace['/%D%/'] = strftime('%D');
			$arReplace['/%e%/'] = strftime('%e');
			$arReplace['/%g%/'] = strftime('%g');
			$arReplace['/%G%/'] = strftime('%G');
			$arReplace['/%h%/'] = strftime('%h');
			$arReplace['/%H%/'] = strftime('%H');
			$arReplace['/%I%/'] = strftime('%I');
			$arReplace['/%j%/'] = strftime('%j');
			$arReplace['/%m%/'] = strftime('%m');
			$arReplace['/%M%/'] = strftime('%M');
			$arReplace['/%n%/'] = strftime('%n');
			$arReplace['/%p%/'] = strftime('%p');
			$arReplace['/%r%/'] = strftime('%r');
			$arReplace['/%R%/'] = strftime('%R');
			$arReplace['/%S%/'] = strftime('%S');
			$arReplace['/%t%/'] = strftime('%t');
			$arReplace['/%T%/'] = strftime('%T');
			$arReplace['/%u%/'] = strftime('%u');
			$arReplace['/%U%/'] = strftime('%U');			
			$arReplace['/%V%/'] = strftime('%V');
			$arReplace['/%w%/'] = strftime('%w');
			$arReplace['/%W%/'] = strftime('%W');
			$arReplace['/%x%/'] = strftime('%x');
			$arReplace['/%X%/'] = strftime('%X');
			$arReplace['/%y%/'] = strftime('%y');
			$arReplace['/%y1%/'] = strftime('%y', mktime(date('H'), date('i'), date('s'), date('n'), date('j'), date('Y') + 1)); 
			$arReplace['/%Y%/'] = strftime('%Y');			
			$arReplace['/%Y1%/'] = strftime('%Y', mktime(date('H'), date('i'), date('s'), date('n'), date('j'), date('Y') + 1));			
			$arReplace['/%Z%/'] = strftime('%Z');

			$arReplace['/%widerrufsformular_url%/i'] = '';
			$arReplace['/%widerruf_url%/i'] = $this->getURL(wpsg_ShopController::URL_WIDERRUF);
			$arReplace['/%agb_url%/i'] = $this->getURL(wpsg_ShopController::URL_AGB);
			
			/* Shopinfo */
			$arReplace['/%shopinfo_name%/i'] = $this->get_option('wpsg_shopdata_name');
			$arReplace['/%shopinfo_owner%/i'] = $this->get_option('wpsg_shopdata_owner');
			$arReplace['/%shopinfo_tel%/i'] = $this->get_option('wpsg_shopdata_tel');
			$arReplace['/%shopinfo_fax%/i'] = $this->get_option('wpsg_shopdata_fax');
			$arReplace['/%shopinfo_email%/i'] = $this->get_option('wpsg_shopdata_email');
			$arReplace['/%shopinfo_taxnr%/i'] = $this->get_option('wpsg_shopdata_taxnr');
			$arReplace['/%shopinfo_ustidnr%/i'] = $this->get_option('wpsg_shopdata_ustidnr');
			$arReplace['/%shopinfo_street%/i'] = $this->get_option('wpsg_shopdata_street');
			$arReplace['/%shopinfo_zip%/i'] = $this->get_option('wpsg_shopdata_zip');
			$arReplace['/%shopinfo_city%/i'] = $this->get_option('wpsg_shopdata_city');
			$arReplace['/%shopinfo_bankname%/i'] = $this->get_option('wpsg_shopdata_bank_name');
			$arReplace['/%shopinfo_accountowner%/i'] = $this->get_option('wpsg_shopdata_bank_owner');
			$arReplace['/%shopinfo_iban%/i'] = $this->get_option('wpsg_shopdata_bank_iban');
			$arReplace['/%shopinfo_bic%/i'] = $this->get_option('wpsg_shopdata_bank_bic');
			
			/* Platzhalter für die Warenkorbdarstellung, da es recht aufwendig ist suche ich hier vorher nach dem Vorkommen */			
			if (strpos(strtolower($value), '%basket_html%') !== false) $arReplace['/%basket_html%/i'] = $this->render(WPSG_PATH_VIEW.'/mailtemplates/html/order.phtml', false);
			if (strpos(strtolower($value), '%basket_txt%') !== false) $arReplace['/%basket_txt%/i'] = $this->render(WPSG_PATH_VIEW.'/mailtemplates/order.phtml', false);
			
			$revocation_form = WPSG_PATH_UPLOADS.'wpsg_revocation/'.$this->get_option('wpsg_revocationform');			
			if (file_exists($revocation_form) && is_file($revocation_form)) $arReplace['/%widerrufformular_pdf_url%/i'] = WPSG_URL_UPLOADS.'wpsg_revocation/'.$this->get_option('wpsg_revocationform');
			
			$this->callMods('replaceUniversalPlatzhalter', array(&$arReplace, $order_id, $kunden_id, $rechnung_id, $product_id, $product_index));
			
			foreach ($arCustomReplace as $k => $v) { $arReplace[$k] = $v; } 
			
			$value = preg_replace(array_keys($arReplace), array_values($arReplace), $value);
			
			// Sollte irgendein platzhalter mal nicht ersetzt werden denn clear ich das 
			if (isset($this->noReplace) && $this->noReplace === true) return $value;
			else
			{
				
				$value = preg_replace('/%[A-Za-z][^(%|\040)]*%/', '', $value);
			
				return $value;
				
			}
			
		} // public function replaceUniversalPlatzhalter($value, $order_id = false, $kunden_id = false, $rechnung_id = false)
		
		/**
		 * Gibt das Verzeichnis zurück, in dem der Shop temporäre Daten ablegen kann
		 */
		public function getTempDir($getUrl = false)
		{
			
			$path = '';
			
			if ($this->isMultiBlog())
			{
				
				$path = WPSG_PATH_CONTENT.WPSG_MB_UPLOADS.'/wpsg/wpsg_temp/';
				$url = WPSG_URL_CONTENT.WPSG_MB_UPLOADS.'/wpsg/wpsg_temp/';
				
			}
			else
			{
				
				$path = WPSG_PATH_CONTENT.'uploads/wpsg_temp/';
				$url = WPSG_URL_CONTENT.'uploads/wpsg_temp/';
				
			}

			if (!file_exists($path)) wpsg_mkdir($path);
			
			if ($getUrl === true) return $url; else return $path;
			
		} // public function getTempDir()
		
		/**
		 * Generiert eine Temporäre Datei und gibt den Pfad dahingehend zurück
		 */
		public function getTempName($filename = '')
		{
			
			$path = $this->getTempDir();
			$filename = trim(time().rand(0, 1000)).$filename;
									
			return $path.$filename;
			
		} // public function getTempName()
 
		/**
		 * Führt ein Kommando aus und gibt die Programmausgabe zurück
		 */
		function exec($cmd) 
		{
			
            $back="";
            
            $io = array();
            
            $p = proc_open($cmd,
                           array(1 => array('pipe', 'w'),
                                 2 => array('pipe', 'w')),
                           $io);
 
            while (!feof($io[1])) {
                $back .= htmlspecialchars(fgets($io[1]),
                                                        ENT_COMPAT, 'UTF-8');
            }
            
            while (!feof($io[2])) {
                $back .= htmlspecialchars(fgets($io[2]),
                                                        ENT_COMPAT, 'UTF-8');
            }
 
            fclose($io[1]);
            fclose($io[2]);
            
            proc_close($p);
            
            return $back;
            
		} // function exec($cmd) 
		
		/**
		 * Fügt in die Dummy phtml ein zu übersetzenden String hinzu
		 */
		public function addTranslationString($key, $value)
		{
			
			try 
			{
		 
				if (file_exists(WPSG_PATH_TRANSLATION))
				{
					 					
					preg_match_all('/\$(.*)\040+\=\040+\_\_\(\'([^\']*)/i', file_get_contents(WPSG_PATH_TRANSLATION), $matches);
					
					if (@sizeof($matches[1]) != @sizeof($matches[2]))
					{
						
						$this->addBackendError(__('Unerwarteter Fehler beim schreiben der Übersetzungsdatei.', 'wpsg'));
						return;
						
					}					
					
					foreach ($matches[1] as $k => $m)
					{
						
						if ($matches[1][$k] == $key)
						{
							
							$bDrin = true;
							$matches[2][$k] = $value;
							
						}
						
					}
					
					if (!$bDrin)
					{
						
						$matches[1][] = $key;
						$matches[2][] = $value;
						
					}
					
					$strFile = '';
					
					foreach ($matches[1] as $k => $m)
					{
						
						$strFile .= '$'.$matches[1][$k]." = __('".$matches[2][$k]."', 'wpsg');\r\n";
						
					}
					
					@file_put_contents(WPSG_PATH_TRANSLATION, "<?php die(); \r\n".$strFile."\r\n?>");
					
				}
				else
				{
	
					// Leere Datei erstellen
					@file_put_contents(WPSG_PATH_TRANSLATION, "<?php die(); \r\n$".$key." = __('".$value."', 'wpsg'); \r\n?>");
					
				}
				
			}
			catch (Exception $e)
			{
				
				$this->addBackendError('nohspc_'.__('Sprachdatei konnte nicht geschrieben werden! Setzen Sie bitte Schreibrechte auf folgender Datei überprüfen:<br /><b>'.WPSG_PATH_TRANSLATION.'</b>', 'wpsg'));
				
			}
			
		} // public function addTranslationString($key, $value)
		
		/**
		 * Prüft allgemeine Fehler und gibt Sie im Backend aus 
		 */
		public function checkGeneralBackendError()
		{
			
			// Bei Ajaxanfragen etc. nix machen
			if (isset($_REQUEST['noheader']) && $_REQUEST['noheader'] == '1') return;
			
			if (is_array($this->arLizenz) && isset($this->arLizenz['l']))
			{
				
				// Hinweis auf nicht registrierte Domains
				if ((!isset($_REQUEST['subaction']) || $_REQUEST['subaction'] != 'domains') && (isset($_REQUEST['do']) && $_REQUEST['do'] != 'register'))
				{
				
					$arURLs = $this->get_option('wpsg_registredURLs');
					
					$url = preg_replace('/(.*)\/\//', '', $this->get_option('siteurl'));
					
					if (!in_array($url, (array)$arURLs))
					{
						
						$this->addBackendMessage('nohspc_'.wpsg_translate(__('<b>wpShopGermany:</b> Bitte registrieren Sie diese Domain. Sie können dies ganz einfach im <a href="#1#">Lizenzmanager</a> durchführen.', 'wpsg'), WPSG_URL_WP.'wp-admin/admin.php?page=wpsg-Admin&action=registrierung'));
						
					}
					
				}
				
			}
			
			if (
				$this->get_option("wpsg_version_installed", true) != false &&
				$this->get_option("wpsg_version_installed", true) != WPSG_VERSION && 
				$this->get_option('wpsg_message_db') != '1')				
			{
				
				$this->addBackendError('nohspc_'.wpsg_translate(
					__('Ihre Datenbankversion ist nicht auf dem aktuellen Stand, aktualisieren Sie die Datenbank, indem Sie <a href="#1#">hier</a> klicken.<br />Klicken Sie <a href="#1#">hier</a>, um die Meldung auszublenden.', 'wpsg'),
					WPSG_URL_WP.'wp-admin/admin.php?page=wpsg-Admin&subaction=allgemein&do=update&submit=1&noheader=1',
					WPSG_URL_WP.'wp-admin/admin.php?page=wpsg-Admin&noheader=1&action=clearMessage&wpsg_message=wpsg_message_soaphint&wpsg_redirect='.rawurlencode($_SERVER['REQUEST_URI'])
				));
				
			}
			
			if (!is_object($this->getDefaultCountry()))
			{
				
				$this->addPersistentBackendError(wpsg_translate(
					__('Es wurde kein Standardland definiert, der Shop kann so nicht korrekt betrieben werden. Bitte überprüfen Sie die <a href="#1#">Länderkonfiguration</a>.', 'wpsg'),
					WPSG_URL_WP.'wp-admin/admin.php?page=wpsg-Admin&subaction=laender'
				), 'wpsg_message_nodefaultcountry');
				
			}
			
			if (!class_exists('SoapClient') && $this->get_option('wpsg_message_soaphint') != '1')
			{
				
				$this->addPersistentBackendError(wpsg_translate(
					__('Ihrem Server fehlt die PHP-Bibliothek für die SOAP-Unterstützung. Eine Registrierung Ihrer Domain ist somit nicht möglich! <br />Weitere Informationen finden Sie in unseren <a target="_blank" href="http://wpshopgermany.maennchen1.de/faqs/wie-pruefe-ich-ob-soap-und-curl-auf-meinem-server-aktiviert-sind/">FAQ</a>. Klicken Sie <a href="#1#">hier</a>, um die Meldung auszublenden.', 'wpsg'),
					WPSG_URL_WP.'wp-admin/admin.php?page=wpsg-Admin&noheader=1&action=clearMessage&wpsg_message=wpsg_message_soaphint&wpsg_redirect='.rawurlencode($_SERVER['REQUEST_URI'])
				),
            	'wpsg_message_nosoap');

			}

			if (@$_REQUEST['subaction'] != 'seiten' && ($this->get_option('wpsg_page_basket') === false || $this->get_option('wpsg_page_basket') <= 0 || !get_page($this->get_option('wpsg_page_basket'))))
			{
								
				// Keine Warenkorbseite definiert
				$this->addPersistentBackendError(
					wpsg_translate(
						__('Bitte überprüfen Sie die <a href="#1#">Seitenkonfiguration</a>. Die Warenkorbseite muss korrekt angegeben sein, sonst funktioniert der Shop nicht.', 'wpsg'),
						WPSG_URL_WP.'wp-admin/admin.php?page=wpsg-Admin&subaction=seiten'
					),
					'wpsg_messsage_basketpage'
				);
				
			}
			
			// Schreibrechte auf der Sprachdatei
			if (file_exists(WPSG_PATH_TRANSLATION) && !is_writable(WPSG_PATH_TRANSLATION)) { $this->addBackendError('nohspc_'.__('<b>wpShopGermany:</b> Sprachdatei kann nicht geschrieben werden! Prüfen Sie die Schreibrechte auf folgender Datei:<br /><b>'.WPSG_PATH_TRANSLATION.'</b>', 'wpsg')); }
			
			// Kundenmailanhang prüfen
			if (wpsg_isSizedString($this->get_option('wpsg_kundenmail_attachfile')) && !file_exists(wpsg_getUploadDir('wpsg_mailconf').$this->get_option('wpsg_kundenmail_attachfile'))) 
				$this->addBackendError('nohspc_'.wpsg_translate(__('Es ist ein Anhang der Kundenmail definiert, die Datei wurde aber nicht gefunden. <a href="#1#">Zur E-Mail Konfiguration</a>', 'wpsg'), WPSG_URL_WP.'wp-admin/admin.php?page=wpsg-Admin&subaction=emailconf'));
			
			// Alte UserViews checken
			if (file_exists(WPSG_PATH_USERVIEW_OLD))
			{
				
				$this->addPersistentBackendError(wpsg_translate(
					__('Es existieren noch alte angepasste Templates unter #1#. Kopieren Sie diese bitte nach #2#. Zukünftig werden die Templateanpassungen nicht mehr im Pluginverzeichnis gesucht. Weitere Informationen erhalten Sie auch <a href="#3#">hier</a> oder auch in unserem kostenlosen <a href="#4#">Forum</a>.', 'wpsg'),
					WPSG_PATH_USERVIEW_OLD,
					WPSG_PATH_USERVIEW,
					'http://wpshopgermany.maennchen1.de/?p=5130',
					'http://forum.maennchen1.de'
           		), 'wpsg_message_olduserview');
				
			}
			
			if (!wpsg_isSizedString($this->get_option('wpsg_shopdata_name')) && !wpsg_isSizedString($this->get_option('wpsg_shopdata_owner')) && !wpsg_isSizedString($this->get_option('wpsg_shopdata_tel')) && !wpsg_isSizedString($this->get_option('wpsg_shopdata_fax')) && !wpsg_isSizedString($this->get_option('wpsg_shopdata_email')) &&
            	!wpsg_isSizedString($this->get_option('wpsg_shopdata_street')) && !wpsg_isSizedString($this->get_option('wpsg_shopdata_zip')) && !wpsg_isSizedString($this->get_option('wpsg_shopdata_city')) &&
             	!wpsg_isSizedString($this->get_option('wpsg_shopdata_bank_owner')) && !wpsg_isSizedString($this->get_option('wpsg_shopdata_bank_iban')) && !wpsg_isSizedString($this->get_option('wpsg_shopdata_bank_bic')))
			{
				
				$this->addBackendError(wpsg_translate(
            		'nohspc_'.__('Sie haben die Angaben zum Shop noch nicht ausgefüllt. Klicken sie <a href="#1#">hier</a> um die Angaben zu vervollständigen.', 'wpsg'),
					WPSG_URL_WP.'wp-admin/admin.php?page=wpsg-Admin&subaction=shopdata'
				), 'wpsg_message_shopdata');
				
			}
			
			if (!$this->hasMod('wpsg_mod_ordercondition'))
			{
			
				$this->addPersistentBackendError(wpsg_translate(
            		__('Ab der wpShopGermany Version 3.4 kann das kostenlose Modul "<a href="#1#">Bestellbedingungen</a>" verwendet werden. Sie können es <a href="#2#">hier</a> konfigurieren. Überprüfen Sie auch die anderen Änderungen, die wir <a href="#3#">in unserem Artikel</a> näher erläutern.', 'wpsg'),
					'http://wpshopgermany.maennchen1.de/?p=13232',
					WPSG_URL_WP.'wp-admin/admin.php?page=wpsg-Admin&action=module&modul=wpsg_mod_ordercondition',
					'http://wpshopgermany.maennchen1.de/?p=13952'
				), 'wpsg_message_ordercondition_34');
								
			}
			
			$this->callMods('checkGeneralBackendError');
			
			/** Schreibrechte auf dem Pluginverzeichnis um Module zu installieren
			  
			if (!is_writable(WPSG_PATH) && $this->get_option('wpsg_message_pluginwrite') != '1') $this->addBackendError('nohspc_'.wpsg_translate(__('<b>wpShopGermany:</b> Das Pluginverzeichnis (#1#) ist nicht durch den Webserver beschreibbar. Die wpShopGermany Module lassen sich möglicherweise nicht automatisch installieren. Klicken Sie <a href="#2#">hier</a>, um die Meldung auszublenden.', 'wpsg'), 
				WPSG_PATH,
				WPSG_URL_WP.'wp-admin/admin.php?page=wpsg-Admin&noheader=1&action=clearMessage&wpsg_message=wpsg_message_pluginwrite&wpsg_redirect='.rawurlencode($_SERVER['REQUEST_URI'])
			));
			
			*/
			
		} // public function checkGeneralBackendError()
		
		/**
		 * Wird von Wordpress aufgerufen über add_filter('wp_head ...
		 */
		public function wp_head()
		{
			
			echo '<!-- wpShopGermany Version '.WPSG_VERSION.' -->';
						
			$this->callMods('wp_head');
			
		} // public function wp_head()

		/**
		 * Wird von Wordpress aufgerufen über add_filter('wp_footer ...
		 */
		public function wp_foot()
		{
			
			// Variable wird mein anzeigen eines Warenkorbes oder beim Anzeigen eines Produktes aufgerufen
			// Widget kann dies auch auslösen
			if ($this->get_option('wpsg_geo_determination') !== '4')
			{
			
				$default_country = $this->getDefaultCountry();
			
				if ($this->showEULayer && wpsg_geo_code() != strtolower($default_country->kuerzel))
				{
				
					// Wurde der Dialog schon beantwortet?
					if (!isset($_SESSION['wpsg']['priceDialog']) || $_SESSION['wpsg']['priceDialog'] !== true)
					{
					
						echo '<script type="text/javascript">/* <![CDATA[ */';
											
						//echo 'jQuery(document).ready(function() { wpsg_customerquestion("'.$this->getCurrentURL().'"); } );';
						
						//Lieber die REQUEST_URI, damit alle _GET Variablen erhalten bleiben
						echo 'jQuery(document).ready(function() { wpsg_customerquestion("'.$_SERVER['REQUEST_URI'].'"); } );';
						
						echo '/* ]]> */</script>'; 
						
					}
					 
				}
				
			}
			
			$this->callMods('wp_foot');
			
		} // public function wp_foot()
		
		/**
		 * Löscht eine einzellne Bestellung und  alle Abhängigkeiten
		 */
		public function delOrder($order_id)
		{
			
			$oOrder = wpsg_order::getInstance($order_id);
			$oOrder->delete();
									
		} // public function delOrder()
		
		/**
		 * Verteilt den Wert $value auf die MwSt Sätze in $arBasket
		 * $value wird Brutto übergeben
		 */
		public function subMwSt(&$arBasket, $value)
		{
					
			// Anteilig auf die Sätze verteilen
			foreach ((array)$arBasket['mwst'] as $mw_id => $mw)
			{
				 
				if ($mw['base_value'] > 0)
				{
					
					$proz = $mw['base_value'] / $arBasket['sum']['preis_brutto'];	
									
					$arBasket['mwst'][$mw_id]['base_value'] -= $proz * $value;										
					$arBasket['mwst'][$mw_id]['sum'] = wpsg_calculateSteuer($arBasket['mwst'][$mw_id]['base_value'], WPSG_BRUTTO, $mw['value']);
					 
				}
				
			} 
			
			// Mehrwertsteuer Summe korrigieren
			foreach ($arBasket['mwst'] as $mw_id => $mw)
			{
				
				$sum_mwst += $arBasket['mwst'][$mw_id]['sum'];
				
			}
			
			$sub = $arBasket['sum']['mwst'];
			
			$arBasket['sum']['mwst'] = abs($sum_mwst);
						
			return $sub - $arBasket['sum']['mwst']; 
			
		} // public function subMwSt(&$arBasket, $value)
		
		/**
		 * Ermittelt den zu besteuernden Teil eines Nettowertes und verteilt ihn auf die MwSt. Sätze in $arBasket
		 * $value wird in Netto übergeben
		 */
		public function addMwSt(&$arBasket, $value)
		{
			
			if (wpsg_tf($value) <= 0) return 0;
			
			foreach ((array)$arBasket['mwst'] as $mw_id => $mw)
			{
				
				if ($mw['base_value'] > 0)
				{
					
					$proz = $mw['base_value'] / $arBasket['sum']['preis_brutto'];
					
					$arBasket['mwst'][$mw_id]['base_value'] -= wpsg_calculatePreis($proz * $value, WPSG_BRUTTO, $mw['value']);					
					$arBasket['mwst'][$mw_id]['sum'] = wpsg_calculateSteuer($arBasket['mwst'][$mw_id]['base_value'], WPSG_BRUTTO, $mw['value']);
					  
				}
				
			}
			
			// Mehrwertsteuer Summe korrigieren
			foreach ($arBasket['mwst'] as $mw_id => $mw)
			{
				
				$sum_mwst += $arBasket['mwst'][$mw_id]['sum'];
				
			}
			
			$sub = $arBasket['sum']['mwst'];
			
			$arBasket['sum']['mwst'] = abs($sum_mwst);
			
			return $sub - $arBasket['sum']['mwst']; 
			
		} // public function addMwSt(&$arBasket, $value)
		
		/**
		 * Gibt den Wert einer benutzerdefinierten Kundenvariable zurück wenn die Bestellung noch nicht in der Datenbank ist
		 */
		public function getCustomerFieldFromSession($field_id)
		{
			
			if (!isset($_SESSION['wpsg']['checkout']['custom'][$field_id])) return;
			
			$pflicht = $this->loadPflichtFeldDaten();
			
			if (!is_array($pflicht) || !isset($pflicht['custom'][$field_id])) return;
			
			return $_SESSION['wpsg']['checkout']['custom'][$field_id];
			
		} // public function getCustomerFieldFromSession($field_id)
		
		/**
		 * Gibt den Wert einer benutzerdefinierten Kundenvariable zurück wenn die Bestellung schon in der Datenbank ist
		 */
		public function getCustomFieldFromDB($customer_id, $field_id)
		{
			
			$kunde_data = $this->cache->loadKunden($customer_id);
			$kunde_data['custom'] = @unserialize($kunde_data['custom']);

			if (!is_array($kunde_data)) return;
			
			if (!isset($kunde_data['custom'][$field_id])) return;
			
			$pflicht = $this->loadPflichtFeldDaten();
			
			if (!is_array($pflicht) || !isset($pflicht['custom'][$field_id])) return;
			
			return $kunde_data['custom'][$field_id];
			
		} // public function getCustomFieldFromDB($customer_id, $field_id)
		
		/**
		 * Setzt eine Zahlung für eine Bestellung
		 * 
		 * Gibt true zurück wenn die Bestellung komplett beglichen werden kann
		 * 
		 */
		public function setPayMent($order_id, $pay_amount)
		{
			
			$order_data = $this->cache->loadOrder($order_id);
			
			if (round(doubleval($order_data['price_gesamt']), 2) == round(doubleval($pay_amount), 2))
			{
				
				// Alles grün, Zahlung stimmt mit Bestellwert überein
				return true;
				
			}
			else
			{
				
				$logTitle = wpsg_translate(__('Versuchte Zahlung über #1#.', 'wpsg'), wpsg_ff($pay_amount, $this->get_option('wpsg_currency')));
				
				// Hier mal was ins Log schreiben
				$this->db->ImportQuery(WPSG_TBL_OL, array(
					"title" => $logTitle,
					"cdate" => "NOW()",
					"o_id" => wpsg_q($order_id),
					"mailtext" => wpsg_q(print_r($_REQUEST, 1)."\r\n".print_r($_SERVER, 1))
				));
				
			}
			
			return false;
			
		} // public function setPayMent($order_id, $pay_amount)
		
		/**
		 * Lädt die Daten für die Pflichtfelder und beachtet die Übersetzungen
		 */
		public function loadPflichtFeldDaten()
		{
			
			$arPflicht = $this->get_option('wpsg_admin_pflicht');
			
			// Mann|Frau usw. übersetzen
			$arPflicht['anrede_auswahl'] = __($arPflicht['anrede_auswahl'], 'wpsg'); 

			if (wpsg_isSizedArray($arPflicht['custom']))
			{
			
				foreach ($arPflicht['custom'] as $k => $v)
				{
					
					$arPflicht['custom'][$k]['name'] = __($arPflicht['custom'][$k]['name'], 'wpsg');
					$arPflicht['custom'][$k]['auswahl'] = __($arPflicht['custom'][$k]['auswahl'], 'wpsg');
					
				}
			
			}
			
			return $arPflicht;
			
		} // public function loadPflichtFeldDaten()
		
		/**
		 * Baut die Bestellnummer
		 */
		public function buildONR($o_id, $k_id, $knr)
		{
			
			$onr_modul = "";
			if ($this->callMods('buildONR', array(&$k_id, &$o_id, &$onr_modul)) === false)
			{
			
				return $onr_modul;
			
			}
			
			$onr = $this->get_option('wpsg_order_start');
				
			if (trim($this->get_option('wpsg_format_onr')) == '')
			{
				$format = "%onr%";
			}
			else
			{
				$format = $this->get_option('wpsg_format_onr');
			}
				
			$arReplace = array(
					'/%Y%/' => date('Y'),
					'/%m%/' => date('m'),
					'/%d%/' => date('d'),
					'/%H%/' => date('H'),
					'/%i%/' => date('i'),
					'/%s%/' => date('s'),
					'/%oid%/' => $o_id,
					'/%onr%/' => $onr,
					'/%order_onr%/' => $onr,
					'/%kid%/' => k_id,
					'/%knr%/' => $knr,
					'/%kunde_knr%/' => $knr
			);
				
			$strReturn = preg_replace(array_keys($arReplace), array_values($arReplace), $format);
			$strReturn = $this->replaceUniversalPlatzhalter($strReturn, $o_id, $k_id);
				
			// Bestellnummer Zähler hochzählen
			$this->update_option('wpsg_order_start', intval($this->get_option('wpsg_order_start')) + 1);
			
			return $strReturn;
				
		} // private function buildONR($o_id, $k_id)
		
		/**
		 * Erstellt die Kundennummer (Wird vom Basket bei Bestellung und vom Kundenmodul bei Registrierung genutzt)
		 */
		public function buildKNR($k_id)
		{
			
			$knr_modul = "";
			if ($this->callMods('buildKNR', array(&$k_id, &$knr_modul)) === false)
			{
				 
				return $knr_modul;
				
			} 
			
			$knr = $this->get_option('wpsg_customer_start');
			
			if (trim($this->get_option('wpsg_format_knr')) == '')
			{
				$format = "%knr%";
			}
			else
			{
				$format = $this->get_option('wpsg_format_knr');
			}
			
			$arReplace = array(
				'/%Y%/' => date('Y'),
				'/%m%/' => date('m'),
				'/%d%/' => date('d'),
				'/%H%/' => date('H'),
				'/%i%/' => date('i'),
				'/%s%/' => date('s'),
				'/%knr%/' => $knr,
				'/%kid%/' => $k_id,
				'/%kunde_id%/' => $k_id,
				'/%kunde_knr%/' => $knr,
				'/%id%/' => $k_id
			);
			
			$strReturn = preg_replace(array_keys($arReplace), array_values($arReplace), $format);
			$strReturn = $this->replaceUniversalPlatzhalter($strReturn, false, $k_id);
			
			// Kundennummer Zähler hochzählen
			$this->update_option('wpsg_customer_start', intval($this->get_option('wpsg_customer_start')) + 1);
			
			return $strReturn;
			
		} // private function buildKNR($k_id)
		
		/**
		 * Wird aufgerufen wenn ein Fehler im Shop aufgetreten ist
		 */
		public function throwErrorCode($code)
		{
			
			die(wpsg_translate(__('Systemfehler! Fehlercode:#1#', 'wpsg'), $code));
			
		} // public function throwErrorCode($code)

		/**
		 * Hilfsfunktion um die Versandarten zusammenzufügen und Kombinationen zu bilden
		 * Siehe test9() in wpsg_mod_test
		 */
		public function mergeShipping($arShipping1, $arShipping2)
		{
					
			/*
			wpsg_debug("merge");
			wpsg_debug($arShipping1);
			wpsg_debug($arShipping2);
			*/
						
			$arReturn = array();
			 
			$arIntersect = array_intersect($arShipping1, $arShipping2);
									
			if (wpsg_isSizedArray($arIntersect) && (sizeof($arIntersect) > 1 || !array_search('130', $arIntersect)))
			//if (wpsg_isSizedArray($arIntersect))
			{
				
				$arReturn = $arIntersect;
				
			}
			else
			{
			
				// Jedes mit jedem prüfen
				foreach ($arShipping1 as $shipping1)
				{
					
					foreach ($arShipping2 as $shipping2)
					{
						
						if (is_array($shipping1))
						{
	 
							if (!in_array($shipping2, $shipping1))
							{
													
								$s_merge = $shipping1;
								$s_merge[] = $shipping2;
							
								// Ob die Kombination im Rückgabe Array schon gefunden wurde
								$bFoundKombination = false;
								 
								foreach ($arReturn as $r)
								{
									
									if (!wpsg_isSizedArray(array_diff($r, $s_merge)))
									{
										
										$bFoundKombination = true; break;
										
									}
									
								}
								
								if (!$bFoundKombination)
								{
									 
									$arReturn[] = $s_merge;
									
								}
								
							}
							else
							{
								
								$bDrin = false;
								
								foreach ($arReturn as $r)
								{
									
									if (is_array($r) && !wpsg_isSizedArray(array_diff($r, $shipping1))) $bDrin = true;
									
								}
								
								if (!$bDrin) $arReturn[] = $shipping1;
								
							}
							
						}
						else
						{
						
							// Ob die Kombination im Rückgabe Array schon gefunden wurde
							$bFoundKombination = false;
							
							foreach ($arReturn as $r)
							{
								
								if (in_array($shipping1, $r) && in_array($shipping2, $r))
								{
									
									$bFoundKombination = true; break;
																	
								}
								
							}
							
							if (!$bFoundKombination) 
							{
								
								$arReturn[] = array($shipping1, $shipping2);
								
							}
							
						}
						
					}
					
				}
				
			}
			 
			return $arReturn;
			
		} // private function mergeShipping($arShipping1, $arShipping2)
		
		/**
		 * Gibt den Namen der Versandart zurück
		 * Ist notwendig geworden, da die Versandarten zusammengefügt wurden. 
		 * In $this->arShipping sind schon die zusammengefügten Pakete drin 
		 */
		public function getShippingName($shipping_key)
		{
			
			if (array_key_exists($shipping_key, $this->arShipping)) 
			{ 
				
				return __($this->arShipping[$shipping_key]['name'], 'wpsg'); 
			
			} 
			else
			{
				
				return __($this->arShipping[$this->view['basket']['checkout']['shipping']]['sub'][$shipping_key]['name'], 'wpsg');
				
			}
			
		} // public function getShippingName($shipping_key)		
		
		/**
		 * Gibt den Produktnamen als HTML zurück
		 * - Wenn Detailname, dann der Detailname 
		 * - Box^4 wird in Box<span class="wpsg_upper">4</div>
		 * @param bool $detailname Wenn auf true, dann wird der Detailname verwendet wenn vorhanden
		 * @param int $product_id ID des Produktes
		 */
		public function getProductName($product_id, $detailname = false)
		{
			
			$oProduct = wpsg_product::getInstance($product_id);
			
			if (wpsg_isSizedString($oProduct->detailname) && $detailname === true)
			{
				
				$strName = $oProduct->detailname;
				
			}
			else
			{
			
				$strName = $oProduct->name;
				
			}
			
			if (strpos($strName, '^') !== false)
			{

				$strName = preg_replace('/\^/', '<span class="wpsg_upper">', $strName).'</span>';
				
			}
			
			return $strName;
			
		} // public function getProductName($product_id)
		
		/**
		 * Überprüft die vorhandenen Versandarten und entfernt Versandarten die im Warenkorb nicht erlaubt sind
		 */
		public function checkShippingAvailable()
		{
			
			//echo '<pre>';debug_print_backtrace();echo '</pre>'; wpsg_debug("OK");
			
			// Damit es auch ohne View aus wpsg_basket.class beim prüfen der Versandarten aufgerufen werden kann
			if (!wpsg_isSizedArray($this->view['basket'])) $this->view['basket'] = $this->basket->toArray();
			
			if (wpsg_isSizedArray($this->view['basket']['produkte']))
			{
				
				$arSystemShippingAllowed = array_keys($this->arShipping);
				
				$bWillCollect = true;
				
				//wpsg_debug("Im System vorhandene Versandarten:".print_r($arSystemShippingAllowed, 1));
				 
				$i_merge = 0;
				foreach ($this->view['basket']['produkte'] as $basket_product)
				{
					
					$oProduct = $this->cache->loadProductObject($this->getProduktID($basket_product['id']));
					
					if ($oProduct->hasLimitedShipping())
					{
						
						$arProductShippingAllowed = $oProduct->getAllowedShipping();

						if (array_search('130', $arProductShippingAllowed) !== false) $bWillCollect = $bWillCollect && true;
						else $bWillCollect = false;
						
						//wpsg_debug('Produkt '.$basket_product['name'].' erlaubte Versandarten:'.print_r($arProductShippingAllowed, 1));
						//wpsg_debug('System '.print_r($arSystemShippingAllowed, 1));
						
						// Zusammenfügen
						if ($i_merge === 0)
						{
						
							$arSystemShippingAllowed = array_intersect($arSystemShippingAllowed, $arProductShippingAllowed);
							
						}
						else 
						{
						
							$arSystemShippingAllowed = $this->mergeShipping($arSystemShippingAllowed, $arProductShippingAllowed);
							
						}
						
						$i_merge ++;
						
					}
					
				}
								
				if (wpsg_isSizedArray($arSystemShippingAllowed) && !$this->shipping_alreadymerged)
				{
					
					$this->shipping_alreadymerged = true;
					
					$arShippingNew = array();
					
					if ($this->hasMod('wpsg_mod_willcollect') && wpsg_isSizedInt($this->get_option('wpsg_mod_willcollect_aktiv')) && $bWillCollect === true && array_key_exists('130', $this->arShipping))
					{
						
						$arShippingNew['130'] = $this->arShipping['130'];
						
					}

					foreach ($arSystemShippingAllowed as $shipping)
					{
						
						if (is_array($shipping))
						{
							
							asort($shipping, SORT_STRING);
							
							$subKey = implode('-', $shipping);
														
							$arShippingNew[$subKey] = array(
								'id' => $subKey,
								'sub' => array(),
								'price' => 0
							);
							
							foreach ($shipping as $subShipping)
							{
								
								$sub = $this->arShipping[$subShipping];
								
								$arShippingNew[$subKey]['name'] = implode(' + ', wpsg_trim(array_merge(array($sub['name']), (array)explode(',', $arShippingNew[$subKey]['name']))));
								$arShippingNew[$subKey]['hint'] = implode('<br /><br />', wpsg_trim(array_merge(array($sub['hint']), (array)explode(',', $arShippingNew[$subKey]['hint']))));
								
								if (isset($arShippingNew[$subKey]['price'])) $arShippingNew[$subKey]['price'] = $arShippingNew[$subKey]['price'] + $sub['price'];
								else if (isset($sub['price'])) $arShippingNew[$subKey]['price'] = $sub['price'];
								
								$arShippingNew[$subKey]['sub'][$subShipping] = $sub;
								
							}
							
						}
						else
						{
							
							$arShippingNew[$shipping] = $this->arShipping[$shipping];
							
						}
																		
					}
					
					$this->arShipping = $arShippingNew;

					//wpsg_debug("Zur verfügung stehende Versandarten: ".print_r($arShippingNew, 1));
					
				}
				
			}
						
			$this->callMods('checkShippingAvailable', array(&$this->arShipping, &$this->view['basket']));
			
		} // public function checkShippingAvailable()
		
		/**
		 * Überprüft die vorhandenen Zahlungsarten und entfernt Zahlungsarten die im Warenkorb nicht elaubt sind
		 */
		public function checkPaymentAvailable()
		{

			if (wpsg_isSizedArray($this->view['basket']['produkte']))
			{

				foreach ($this->view['basket']['produkte'] as $basket_product)
				{
					
					$oProduct = $this->cache->loadProductObject($this->getProduktID($basket_product['id']));
					 
					if ($oProduct->hasLimitedPayment())
					{
						
						$arPaymentAllowed = $oProduct->getAllowedPayment();
						
						foreach ($this->arPayment as $payment_key => $payment)
						{
						 
							if (!in_array($payment['id'], $arPaymentAllowed))
							{
								 
								unset($this->arPayment[$payment_key]);
								
							}
							
						}
						
					}
					
				}
				
			}
			
			$this->callMods('checkPaymentAvailable', array(&$this->arPayment, &$this->view['basket']));
			
		} // public function checkPaymentAvailable()
		
		/**
		* Gibt den Namen der Zahlungsart zurück (Eingebaut für CrefoPay)
		* Standardmäßig wird der Name aus $this->shop->arPayment genommen
		*
		* @param Integer $payment_type Key der Zahlungsart
		* @param Integer $order_id BestellID
		*/
		public function getPaymentName($payment_type, $order_id) 
		{
 
			$payment_name = $this->arPayment[$payment_type]['name']; 
			
			$this->callMods('getPaymentName', array($payment_type, $order_id, &$payment_name));
			
			return $payment_name;
			
		} // public function getPaymentName($payment_type, $order_id) 
		
		/**
		 * Ermittelt ob im Backend Netto oder Brutto Preise angezeigt und definiert werden sollen
		 */
		public function getBackendTaxview()
		{
			
			return $this->get_option('wpsg_preisangaben');
			
		} // public function getBackendTaxview()
		
		/**
		 * Ermittelt ob im Frontend Netto oder Brutto Preise angezeigt werden sollen
		 */
		public function getFrontendTaxview()
		{
			
			if (isset($_SESSION['wpsg']['customertype']) && $_SESSION['wpsg']['customertype'] == 0)
			{
				
				// Hier hat der Kunde die Auswahl "Firmenkunde" getroffen --> Netto anzeigen
				return WPSG_NETTO;
				
			}
			
			$nFrontendTaxview = $this->get_option('wpsg_preisangaben_frontend');
			
			if ($this->hasMod('wpsg_mod_kundenverwaltung'))
			{
				
				$customer_group_id = $this->callMod('wpsg_mod_kundenverwaltung', 'getCustomerGroup');
				
				if (wpsg_isSizedInt($customer_group_id))
				{
					
					$oCustomerGroup = $this->callMod('wpsg_mod_kundenverwaltung', 'getCustomerGroupObject', array($customer_group_id));
					
					if ($oCustomerGroup->calculation >= 0)
					{
						
						$nFrontendTaxview = $oCustomerGroup->calculation;
						
					}
					
				}
				
			}
				
			return $nFrontendTaxview;
			
		} // public function getFrontendTaxview()
		
	} // class ShopController extends SystemController
	
?>