<?php
	
	/**
	 * Prüfen ob Ajax-Request vorliegt
	 * @return	boolean
	 */
	function wpsg_isAjaxRequest()
	{

		if(isset($_REQUEST['transfer']) && $_REQUEST['transfer'] == 'ajax')
		{
			return true;	
		}
		else if(!empty($_SERVER['HTTP_X_REQUESTED_WITH']) && strtolower($_SERVER['HTTP_X_REQUESTED_WITH']) == 'xmlhttprequest') 
		{
			return true;
		}
		
		return false;
	
	}

	/**
	 * Arraysortierung
	 * @param 	array	zu sortierendes Array
	 * @param 	string	zu sortierende Spalte
	 * @return	array
	 */
	function wpsg_array_csort($marray, $column) 
	{
		
		foreach ($marray as $row) 
		{
	   		$sortarr[] = $row[$column];
		}
	 	@array_multisort($sortarr, $marray);
	 	
	 	return $marray;
	 	
	}
	 
	/**
	 * Wie array_unique nur Multidimensional
	 */
	function wpsg_array_unique($ar)
	{
 
		$arRewrite = array(); $arHashes = array();
		
		foreach($ar as $k => $v) 
		{

			$hash = md5(serialize($v));

			if (!isset($arHashes[$hash])) 
			{
				
				$arHashes[$hash] = $hash;
				$arRewrite[$k] = $v;
								
			}
			
		}
		
		return $arRewrite;
		
	} // function wpsg_array_unique($ar)	
	
	/**
	 * Prüft die Eingabe eines Geburtsdatums auf Gültigkeit
	 * @param String $val
	 */
	function wspg_isValidGeb(&$val)
	{
		
		if (wpsg_isSizedString($val) && preg_match('/\d{2}\.\d{2}\.\d{4}/', $val)) return true;
		else return false;
		
	} // function wspg_isValidGeb($val)
	
	/**
	 * Prüft die Eingabe einer E-Mail Adresse auf gültigkeit
	 * @param String $val
	 */
	function wpsg_isValidEMail(&$val)
	{
		
		if (wpsg_isSizedString($val) && strpos($val, '@') !== false) return true;
		else return false;
		
	} // function wpsg_isValidEMail($val)
	
	/**
	 * Setzt einen Wert oder addiert ihn
	 * Um Warnungen zu verhindern wenn man einen Wert auf eine Variable addiert die möglicherweise nicht definiert ist
	 */
	function wpsg_addSet(&$arrayElement, $addSet)
	{
		
		if (isset($arrayElement))
		{
			
			$arrayElement += $addSet;			
			
		}
		else
		{
			
			$arrayElement = $addSet;
			
		}
		
	}
	
	/**
	 * Versucht den für den Kunden aktuellen Ländercode (Kürzel) zu ermitteln
	 */
	function wpsg_geo_code()
	{
		
		$country_code = false;
		
		// GeoIP
		if (isset($_SERVER['GEOIP_COUNTRY_CODE']) && $GLOBALS['wpsg_sc']->get_option('wpsg_geo_determination') == '1')
		{
				
			// Apache mod_geoip
			$country_code = $_SERVER['GEOIP_COUNTRY_CODE'];
							
		}		
		else if (function_exists("geoip_country_code_by_name") && $GLOBALS['wpsg_sc']->get_option('wpsg_geo_determination') == '2')
		{
				
			// PECL php_geoip
			$country_code = geoip_country_code_by_name($_SERVER["REMOTE_ADDR"]); 
				
		}
		else if (wpsg_isSizedString($_SERVER['HTTP_ACCEPT_LANGUAGE']) && $GLOBALS['wpsg_sc']->get_option('wpsg_geo_determination') == '3')
		{
				
			if (strpos($_SERVER['HTTP_ACCEPT_LANGUAGE'], ',') !== false)
			{
		
				$country_code = array_shift(explode(',', $_SERVER['HTTP_ACCEPT_LANGUAGE']));
		
			}
			else
			{
		
				$country_code = $_SERVER['HTTP_ACCEPT_LANGUAGE'];
		
			} 
			 
		}
		
		// Sollte der Code das format xx-XX haben
		if (preg_match('/(.*)-(.*)/', $country_code)) $country_code = preg_replace('/-(.*)/', '', $country_code);
		
		if (wpsg_isSizedString($country_code)) return strtolower($country_code);
		else return false;
		
	}
	
	/**
	 * Angepasste Sortierfunktion, die Umlaute beachtet
	 * Ruft wpsg_asort_function über uasort auf
	 */
	function wpsg_asort(&$ar)
	{
		
		uasort($ar, 'wpsg_asort_function');
		
	} // function wpsg_asort($ar)
	
	/**
	 * Sortierfunktion für wpsg_asort
	 */
	function wpsg_asort_function($a, $b)
	{
		
		$arSearch = array("Ä", "ä", "Ö", "ö", "Ü", "ü", "ß", "-");
		$arReplace = array("Ae", "ae", "Oe", "oe", "Ue", "ue", "ss", " ");
		
		$a = str_replace($arSearch, $arReplace, $a);
		$b = str_replace($arSearch, $arReplace, $b);
		
		if ($a == $b) return 0;
		else return ($a < $b)?-1:1;
		
	} // function wpsg_asort_function($a, $b)
	
	function wpsg_array_csort_pk_function($accountA, $accountB)
	{

		$key = $GLOBALS['wpsg_array_csort_pk_key'];
		
		$arSearch = array("Ä", "ä", "Ö", "ö", "Ü", "ü", "ß", "-");
		$arReplace = array("Ae", "ae", "Oe", "oe", "Ue", "ue", "ss", " ");

		$a = str_replace($arSearch, $arReplace, $accountA[$key]);
		$b = str_replace($arSearch, $arReplace, $accountB[$key]);
		
		if ($a == $b) return 0;
		else return ($a < $b)?-1:1;
		
	} // function wpsg_array_csort_pk_function($accountA, $accountB)
	
	function wpsg_array_csort_pk($accounts, $key)
	{
		
		$GLOBALS['wpsg_array_csort_pk_key'] = $key;
		uasort($accounts, 'wpsg_array_csort_pk_function');
		
		return $accounts;
							    
	}

	function wpsg_tax_groups($noRata = false)
	{
		
		$arTaxGroups = array(
			'0' => __('anteilig', 'wpsg'),
			'a' => 'A',
			'b' => 'B',
			'c' => 'C',
			'd' => 'D',
			'e' => 'Nullsatz'	
		);
		
		if ($noRata === true) unset($arTaxGroups[0]);
		
		foreach ($arTaxGroups as $tax_key => &$tax_label)
		{
			
			if (!in_array($tax_key, array('0', 'e')))
			{
			
				$default_country = $GLOBALS['wpsg_sc']->getDefaultCountry();

				if (is_object($default_country))
				{
				
					$tax_value = $default_country->getTax($tax_key);			
					if (!is_null($tax_value)) $tax_label .= ' ('.wpsg_ff(wpsg_tf($tax_value), '%').' / '.$default_country->kuerzel.')';
					
				}
				
			}
			
		}
		
		return $arTaxGroups;
		
	} // function wpsg_tax_groups()
	
	function wpsg_prepare_for_debug(&$value)
	{
		
		if (is_array($value))
		{
			
			foreach ($value as $k => $v)
			{
				
				if (is_object($v)) $value[$k] = 'Object['.get_class($v).']';
				else if (is_array($v)) wpsg_prepare_for_debug($value[$k]);
				
			}
			
		}
		
	}
	
	/**
	 * Debug Funktion, die den übergebenen Wert ausgibt wenn die Option im Backend aktiviert ist.
	 */
	function wpsg_debug($value)
	{
		 
		if ($GLOBALS['wpsg_sc']->get_option('wpsg_debugModus') != "1") return;
		
		echo '<pre style="color:red;">';
		
		if (is_array($value))
		{
			
			wpsg_prepare_for_debug($value);
			
			
			print_r($value);
			echo '</pre>';
			
		}
		else if (is_bool($value))
		{
			
			if ($value === true) echo 'true';
			else echo 'false';
			
		}
		else
		{
			echo $value;
		}
		
		echo '</pre>';
		
	} // function wpsg_debug($value)
	
	/**
	 * Entfernt aus einem Wert / Array alle XSS Attacken
	 */
	function wpsg_xss($value)
	{
		
		if (is_array($value))
		{
			
			foreach ($value as $k => $v)
			{
				
				$value[$k] = wpsg_xss($v);
				
			}
			
		}
		else
		{
			
			$value = strip_tags($value);
			
		}
		
		return $value;
		
	} // function wpsg_xss($value)
	
	/**
	 * Sortiert den Array $ar um, nach den Indexen in $newIndexOrder
	 * @param unknown $ar
	 * @param unknown $newIndexOrder
	 */
	function wpsg_array_reorder(&$ar, $newIndexOrder)
	{
		
		$ar_alt = $ar;
		$ar = array();
		
		$index = 0;
		foreach ($newIndexOrder as $order)
		{
			
			if (array_key_exists($order, $ar_alt))
			{
			
				$ar[$index] = $ar_alt[$order];
				unset($ar_alt[$order]);
				
			}
			
			$index ++;
			
		}
		
		if (wpsg_isSizedArray($ar_alt))
		{
			
			$GLOBALS['wpsg_sc']->throwErrorCode('100_8');
			
		}
		
	} // function wpsg_array_reorder(&$ar, $newIndexOrder)
	 
	/**
	 * Escape Funktion für die Datenbank
	 */
	function wpsg_q($value)
	{
		 
		if (is_array($value))
		{
			
			foreach ($value as $k => $v)
			{
				
				$value[$k] = wpsg_q($v);
				
			}
			
			return $value;
			
		}
		else
		{
		
			if (is_object($value))
			{
				
				wpsg_debug(print_r(debug_backtrace(), 1));
				die($GLOBALS['wpsg_sc']->throwErrorCode('100_3'));
				
			}
			
			return esc_sql($value);
			
		}
		
	} // function wpsg_q($value)
	
	/**
	 * Wandelt einen Wert oder einen Array in UTF8 um
	 */
	function wpsg_toUtf8($value)
	{
		
		if (is_array($value))
		{
			
			foreach ($value as $k => $v)
			{
				
				$value[$k] = wpsg_toUtf8($v);
				
			}
			
			return $value;
			
		}
		else
		{
			
			return utf8_encode($value);
			
		}
		
	} // function wpsg_toUtf8($value)
	
	/**
	 * Array Merge und Indexe nicht neu nummerieren
	 * Siehe: http://de2.php.net/manual/de/function.array-merge.php#106803
	 */
	function wpsg_array_merge($a, $b)
	{
						
		$result = array_diff_key((array)$a, (array)$b) + (array)$b;
		
		return $result;
		
	} // function wpsg_array_merge($a, $b)
	
	/**
	 * Hilfsfunktion für das Hinzufügen von Attributen (XML)
	 */
	function wpsg_addAttributs($doc, $element, $arAttribute)
	{
		
		foreach ($arAttribute as $name => $value)
		{
			$att = $doc->createAttribute($name);
			$att->appendChild($doc->createTextNode($value));
			$element->appendChild($att);
		}
				
	} // function addAttributs($doc, $element, $arAttributs)
	
	/**
	 * & in den urls wird vom Validator angemeckert ...
	 */
	function wpsg_url($url) { return htmlspecialchars($url); }
	
	/**
	 * Wrapper für htmlspecialchars
	 */
	function wpsg_hspc($string) { if (isset($string)) return htmlspecialchars($string); else return ''; } // function wpsg_hspc($string)
	
	/**
	 * Formatiert einen Double Wert für Ausgaben im Frontend
	 */
	function wpsg_ff($value, $einheit = false, $keep = false)
	{
		
		if (!isset($value)) $value = 0;
		
		if (strpos($value, '%') !== false)
		{
			
			$einheit = '%';
			$value = str_replace('%', '', $value);
			
		}
		
		if ($keep === true)
		{

			$strReturn = preg_replace('/\./', ',', $value);
			
		}
		else
		{

			$stellen = 2;
			$value = doubleval($value);
			   
			if ($value < 1)
			{
				
				preg_match('/0\.(0+)\d/', $value, $match);
				
				if (isset($match[1]))
				{
					
					$stellen = strlen($match[1]) + $stellen;
				
				}
				
			}
			
			$strReturn  = number_format(doubleval($value), $stellen, ',', '.');
			
		}
		
		if ($einheit !== false && $einheit !== true) $strReturn .= ' '.$einheit;
		
		return $strReturn;
		
	} // function wpsg_ff($value)
	
	/**
	 * Versucht Nutzereingaben in valide Floatwerte zu wandeln
	 */
	function wpsg_tf($value, $keepProcent = false)
	{
		
		if ($keepProcent === true && strpos($value, '%') !== false) $keepProcent = true; else $keepProcent = false;
		
		// Alles außer Zahlen, Punkt und Komma entfernen
		$value = preg_replace('/[^\d|^\.|^\,|^\-]/', '', $value);
				
		if (strpos($value, ".") && strpos($value, ","))
		{
			
			// , und . drin				
			if (strpos($value, ",") > strpos($value, "."))
			{
				
				//1.123,23
				return str_replace(",", ".", str_replace(".", "", $value));
				
			}
			else
			{

				//1,234.23
				return str_replace(",", "", $value);
				
			}
			
		}
		
		if ($keepProcent === true)
		{
			return str_replace(",", ".", $value).'%';
		}
		else
		{
			return str_replace(",", ".", $value);
		}
		
	} // function wpsg_tf($value)
	
	/**
	 * Wie round, gibt aber immer ein Double Wert zurück.
	 * Unabhängig von den Locale Einstellungen
	 */
	function wpsg_round($value, $digits = 0)
	{
		
		$value = round($value, $digits);
		
		return wpsg_tf($value);
		
	} // function wpsg_round($value, $digits = 0)
	
	/**
	 * Gibt die RGB Farben im Dezimalformat für einen HEX Farbcode zurück
	 */
	function wpsg_getColor($strHEXCode)
	{
		
		if ($strHEXCode[0] == '#')
	        $strHEXCode = substr($strHEXCode, 1);
	
	    if (strlen($strHEXCode) == 6)
	        list($r, $g, $b) = array($strHEXCode[0].$strHEXCode[1],
	                                 $strHEXCode[2].$strHEXCode[3],
	                                 $strHEXCode[4].$strHEXCode[5]);
	    elseif (strlen($strHEXCode) == 3)
	        list($r, $g, $b) = array($strHEXCode[0].$strHEXCode[0], $strHEXCode[1].$strHEXCode[1], $strHEXCode[2].$strHEXCode[2]);
	    else
	        return false;
	
	    $r = hexdec($r); $g = hexdec($g); $b = hexdec($b);
	    
	    return array($r, $g, $b);
	    
	} // private function getColor($colorcode)
	
	/**
	 * Ausgabe Bufferung beenden und Inhalt verwerfen
	 */
	function wpsg_ob_end_clean()
	{
		
		if (wpsg_isSizedArray(ob_list_handlers()))
		{
				
			foreach (ob_list_handlers() as $h) { ob_end_clean(); }
				
		}
		
	} // function wpsg_ob_end_clean()
	
	/**
	 * Erweitert einen String nach Rechts und kürzt ihn gegebenenfalls
	 */
	function wpsg_pad_right($value, $length)
	{
		
		//$string = str_pad($value, $length, ' ', STR_PAD_RIGHT);
		
		$diff = strlen($value) - mb_strlen($value);
    	$string = str_pad($value, $length + $diff, ' ', STR_PAD_RIGHT);
		
		//if (strlen($string) > $length) $string = substr($string, 0, $length - 2).'..';
		
		return $string;
		
	} // function wpsg_pad($value, $length)
	
	/**
	 * Erweitert einen String nach Links und kürzt ihn gegebenenfalls
	 */
	function wpsg_pad_left($value, $length)
	{
		
		//$string = str_pad($value, $length, ' ', STR_PAD_LEFT);
		
		$diff = strlen($value) - mb_strlen($value);
    	$string = str_pad($value, $length + $diff, ' ', STR_PAD_LEFT);
		
		//if (strlen($string) + $diff > $length) $string = substr($string, 0, $length - 2).'..';
		
		return $string;
		
	} // function wpsg_pad_left($value, $length)
	
	/**
	 * Wandelt eine Datumseingabe aus dem Frontend in ein Datumsformat für die Datenbank um
	 */
	function wpsg_toDate($value)
	{
		
		if (preg_match('/\d{2}\.\d{2}\.\d{4}/', $value))
		{
			
			$arDate = explode('.', $value);
			
			return $arDate[2].'-'.$arDate[1].'-'.$arDate[0];
			
		}
		else if (strtotime($value) > 0)
		{
			
			return date('Y-m-d', strtotime($value));
			
		}
		
		return '0000-00-00';
		
	} // function wpsg_toDate($value)
	
	/**
	 * Wandelt ein Datum aus der Datenbank in ein klar leserliches Datum um
	 */
	function wpsg_fromDate($value, $dateOnly = true)
	{
		 
		if ($value == '0000-00-00') return '';
		
		if ($dateOnly && strtotime($value) != 0) return date('d.m.Y', strtotime($value));
		else if (strtotime($value) != 0) return date('d.m.Y H:i:s', strtotime($value));
		
	} // function wpsg_fromDate($value)

	/**
	 * Gibt einen Timestamp formatiert als Datum/Datum+Zeit zurück
	 */
	function wpsg_formatTimestamp($ts, $dateOnly = false)
	{
		
		if ($ts == 0) return '';
		
		if ($dateOnly) return date('d.m.Y', $ts);
		else return date('d.m.Y H:i:s', $ts);
		 
	} // function wpsg_formatTimestamp($ts)
	
	/**
	 * Erweiterung der Gettext Funktion um flexible Parameter
	 * Aufruf in der Form: translate(__("Es wurden #1# Häuser gefunden.", "wpsg"));
	 * 
	 * Zusätzlich wird der String noch durch Htmlspecialchars gejagt
	 */
	function wpsg_translate($string)
	{
		
		$arg = array(); 
			
	  	for($i = 1 ; $i < func_num_args(); $i++)
	  	{
	  		
	  		$arg = func_get_arg($i);
	  		$string = preg_replace("/#".$i."#/", $arg, $string);  	
	  	}
	   
	  	return $string; 
	  	
	} // function wpsg_translate($string)
	
	function wpsg_calculatePreis($value, $brutto_netto, $mwst)
	{
		
		if ($brutto_netto == WPSG_BRUTTO)
		{
			
			// Brutto Preis bestimmen			
			return $value * (1 + ($mwst / 100));
			
		}
		else
		{
			
			// Netto Preis bestimmen
			return $value / (1 + ($mwst / 100));
			
		}
		
	} // public function wpsg_calculate($value, $brutto_netto, $mwst)
		
	/**
	 * Berechnet den Steuerteil eines Wertes
	 
	 * @param double $value Der Preis
	 * @param int $brutto_netto Preis in Netto oder Brutto
	 * @param double $mwst der Mehrwertsteuersatz
	 */
	function wpsg_calculateSteuer($value, $brutto_netto, $mwst)
	{
		
		if ($brutto_netto == WPSG_BRUTTO)
		{
			return $value - wpsg_calculatePreis($value, WPSG_NETTO, $mwst);
		}
		else
		{
			return wpsg_calculatePreis($value, WPSG_BRUTTO, $mwst) - $value;
		}
		
	} // public function wpsg_calculateSteuer($value, $brutto_netto, $mwst)
	
	/**
	 * Wie Explode, nur dass auch noch leere Elemente entfernt werden
	 */
	function wpsg_explode($del, $value)
	{
		
		$arData = explode($del, $value);
		
		foreach ($arData as $k => $v)
		{
			 
			if (trim($v) == "") unset($arData[$k]);
			
		}
		
		return $arData;
		
	} // function wpsg_explode($del, $value)
	
	function wpsg_getIBANBIC($blz, $knr, $country)
	{
		
		$bban_str = str_pad($blz, 8, "0", STR_PAD_LEFT).str_pad($knr, 10, "0", STR_PAD_LEFT);
		$country_num = strval(ord(substr($country_str, 0, 1)) - 55).strval(ord(substr($country_str, 1, 1)) - 55)."00";
		$cksum = str_pad(98-intval(bcmod($bban_str.$country_num, "97")), 2, "0", STR_PAD_LEFT);
		$iban = $country_str.$cksum.$bban_str;
		
		return array(
			'iban' => $iban				
		);
		
	} // function wpsg_getIBANBIC($blz, $knr, $country)
	
	/**
	 * Wie implode, nur das leere Elemente entfernt werden
	 * @param String $del Trennzeichen
	 * @param Array $ar Array der implodiert werden soll
	 */
	function wpsg_implode($del, $ar)
	{
		
		foreach ($ar as $k => $v)
		{
			
			if (trim($v) == '') unset($ar[$k]);
			
		}
		
		return implode($del, $ar);
		
	} // function wpsg_implode($ar)
	
	/**
	 * Wie trim, bei Arrays entfernt es leere Elemente
	 */
	function wpsg_trim($value, $clearEntry = '')
	{
		
		if (is_array($value))
		{
			
			foreach ($value as $k => $v)
			{

				if ($clearEntry === false)
				{
					
					$value[$k] = wpsg_trim($v);	
					
				}
				else
				{
								
					if (is_string($v) && trim($v) == '' || trim($v) == $clearEntry) unset($value[$k]);
					else $value[$k] = wpsg_trim($v);
					
				}
				
			}
			
		}
		else 
		{
			
			$value = trim($value);
			
		}
		
		return $value;
		
	} // function wpsg_trim($value)
	
	/**
	 * Gibt die Dateigröße einer Datei formatiert zurück
	 * @param $size Dateigröße in Bytes der Datei
	 */
	function wpsg_formatSize($size) 
	{
	
		if (is_string($size) && !is_numeric($size)) $size = filesize($size);
		
		$mod = 1024;
	 
	    $units = explode(' ', 'B KB MB GB TB PB');
	
	    for ($i = 0; $size > $mod; $i++) 
	    {
	        $size /= $mod;
	    }
	 
	    return round($size, 2).' '.$units[$i];
	    
	} // private function wpsg_formatSize($size)
	
	function wpsg_isSizedDouble(&$value)
	{
		
		if (!isset($value)) return false;
		if (strlen(doubleval($value)) != strlen($value)) return false;
		
		$dValue = doubleval($value);
		 
		if ($dValue <= 0) return false;
		
		return true;
		
	}
	
	/**
	 * Prüft ob eine Variable gesetzt und > 0 ist
	 * 0.1 ist true und 1 ist true
	 * TEST ist false
	 */
	function wpsg_isSized(&$value)
	{
		
		if (isset($value) && $value > 0)
		{
			
			return true;
			
		}
		
		else return false;
		
	} // function wpsg_isSized(&$value)
	
	/**
	 * Prüfung ob die gegebene Variable numerisch ist und > 0
	 * @param 	int
	 * @return 	boolean
	 */
	function wpsg_isSizedInt(&$int, $value = false)
	{
				
		$isset = true;
		if (!isset($int) || !is_numeric($int)) $isset = false;
		else if ($int <= 0) $isset = false;
		
		if ($isset === true && $value !== false)
		{
			
			if ($value == $int) return true;
			else return false;
			
		}
		
		return $isset;
		
	}	
	
	/**
	 * Prüfung ob befülltes Array vorhanden ist
	 * @param 	array	$array
	 * @return 	boolean
	 */
	function wpsg_isSizedArray(&$array, $size = 1)
	{
		
		if(isset($array) && is_array($array) && sizeof($array) >= $size)
		{
			return true;
		}
		
		return false;
		
	} // function isSizedArray($array, $size = 1)
	
	/**
	 * Gibt einen Float Wert zurück und verhindert Fehler/Warnungen wenn Wert nicht definiert wurde
	 * Wenn Wert nicht definiert wird 0.0 zurückgegeben
	 */
	function wpsg_getFloat(&$value)
	{
		
		if (!isset($value)) return 0.0;
		
		return floatval($value);
		
	} // function wpsg_getFloat(&$value)
	
	/**
	 * Gibt einen String zurück und verhindert Fehler wenn eine Wert nicht definiert wurde
	 */
	function wpsg_getStr(&$value)
	{
		
		if (!isset($value) || !is_string($value)) return '';
		
		return $value;		
		
	} // wpsg_getStr($value = '')
	
	/**
	 * Prüft ob eine Variable gesetzt und true ist
	 */
	function wpsg_isTrue(&$val)
	{
		 
		if (isset($val) && $val === true) return true;
		else return false;
		
	} // function wpsg_isTrue(&$val)
	
	/**
	 * Prüft ob eine Varible ein String ist und die Länge > 0 ist
	 */
	function wpsg_isSizedString(&$strValue, $value = false)
	{
		
		$oldValue = $strValue;
		
		$strValue = strval($strValue);
		
		$isset = true;		
		if (!isset($strValue) || !is_string($strValue)) $isset = false;		
		if (strlen($strValue) <= 0) $isset = false;
		
		if ($isset === true && $value !== false)
		{
			
			if ($value === $strValue)
			{
				
				$strValue = $oldValue;
				return true;
				
			}
			else 
			{
				
				$strValue = $oldValue;
				return false;
				
			}
			
		}
		
		$strValue = $oldValue;
		return $isset;
		
	} // function wpsg_isSizedString($strValue)
	
	/**
	 * Rückgabe der Monatstage eines bestimmenten Monats in einem Jahr
	 * @param	int	$month
	 * @param 	int	$year
	 * @return 	int
	 */
	function wpsg_getDaysofMonth($month, $year)
	{
		$time = mktime(0, 0, 0, $month, 1, $year);
		return date('t', $time);
	}
	
	/**
	 * Gibt das Upload Verzeichnis zurück, in dem Daten von wpShopGermany gespeichert werden
	 * @param string $strPathKey Ein mögliches Unterverzeichnis, wird angelegt
	 * @return string Der absolute Pfad
	 */
	function wpsg_getUploadDir($strPathKey = '')
	{
		
		if ($GLOBALS['wpsg_sc']->isMultiBlog())
		{
			
			$path = WP_CONTENT_DIR.'/'.WPSG_MB_UPLOADS.'/wpsg/'.$strPathKey.'/';
			
		}
		else
		{
			
			$path = WP_CONTENT_DIR.'/uploads/wpsg/'.$strPathKey.'/';
			
		}
		
		if (!file_exists($path))
		{
			
			mkdir($path, 0777, true);
			
		}
		
		return $path;
		
	} // function wpsg_getUploadDir($strPathKey = '')
	
	/**
	 * Verschiebt eine hochgeladene Datei  
	 * @param $strPathkey Pfad unterhalb von Uploads
	 * @param $arFile array $_FILES
	 * @return true or false
	 */
	function wpsg_fileUpload($strPathKey = '', $arFile)
	{
		
		$path = wpsg_getUploadDir($strPathKey);
				
		if (wpsg_isSizedString($arFile['tmp_name']) && $arFile['size'] > 0 && file_exists($arFile['tmp_name']))
		{
			
			$res = move_uploaded_file($arFile['tmp_name'], $path.'/'.$arFile['name']);
			
		}

		return $res;
		
	} // function wpsg_fileUpload($strPathKey = '', $arFile)

?>