typen

class_mcArray.inc.php

+<?php
+/**
+ * @todo
+ *	könnte in
+ *	SEOLinkCache eingesetzt werden
+ */
+class mcArray {
+	public static function returnValueFromKeyPath(array $param_PathAsArray, array $param_Array) {
+		$searcharray = $param_Array;
+		foreach($param_PathAsArray as $key) {
+			if(is_array($searcharray)) {
+				if(array_key_exists($key, $searcharray)) {
+					$searcharray = $searcharray[$key];
+				}
+			} else {
+			  return false;
+			}
+		}
+		return $searcharray;
+	}
+
+	public static $ARRAY_PATTERN = '_#_';
+	/**
+	 *	transformiert Array mit speziellen String Key zu einem normalen Key
+	 *
+	 * @param array param_Array -- Array welches transformiert wird
+	 * @param string param_pattern -- Pattern für den Schlüssel (im Beispiel '_#_')
+	 *
+	 * Array
+		(
+			[bleibt] =>
+			[data_#_1_#_Subject] => kein Betreff
+		)
+	 *
+	 *
+	 *	Array
+		(
+			[bleibt] =>
+			[data] => Array
+				(
+					[1] => Array
+						(
+							[Subject] => kein Betreff
+						)
+
+				)
+		)
+	 */
+	public static function transformArrayWithStringKeyToNormalKey(array &$param_Array, $param_pattern=null) {
+//		D::show($param_Array, '$param_Array');
+		if(is_null($param_pattern)) {
+			$param_pattern = mcArray::$ARRAY_PATTERN;
+		}
+
+		$tmp_POST = array();
+		$tmp_Array = $param_Array;
+		foreach($tmp_Array as $post_key => $post_value) {
+
+			if(FALSE!=strpos($post_key, $param_pattern)) {
+				$tmp_POST[$post_key] = array();
+				$array_key = split($param_pattern, $post_key);
+
+				$tmp_POST_key = null;
+
+				$tmp_POST[$post_key][0]  = array();
+
+				$count_array_key = count($array_key);
+				for($i=0; $i<$count_array_key; $i++) {
+					if(is_null($tmp_POST_key)) {
+						$tmp_POST_key = $array_key[$i];
+					}
+
+					if(!array_key_exists($array_key[$i], $tmp_POST[$post_key][$i])) {
+						$tmp_POST[$post_key][$i][$array_key[$i]] = array();
+					}
+
+					if($count_array_key == $i+1) {
+						$tmp_POST[$post_key][$i][$array_key[$i]]  = $post_value;
+					} else {
+						$tmp_POST[$post_key][$i+1] =& $tmp_POST[$post_key][$i][$array_key[$i]];
+					}
+				}
+
+				mcArray::addArrayValueToArray($param_Array, $tmp_POST[$post_key][0]);
+
+				unset($param_Array[$post_key]);
+			} else {
+				$param_Array[$post_key] = $post_value;
+			}
+		}
+	}
+
+	/**
+	 *	fügt Tabelle mit Werten zu einer bestehenden Tabelle
+	 *
+	 *	siehe phpunit/class_mcArray_PHPTest.inc.php 
+	 *
+	 * @param array $param_Array
+	 * @param <type> $param_ArrayValue
+	 */
+	public static function addArrayValueToArray(array &$param_Array, $param_ArrayValue) {
+		
+		$value_key = array_keys($param_ArrayValue);
+
+		foreach ($value_key as $key) {
+			if(array_key_exists($key, $param_Array)) {
+				mcArray::addArrayValueToArray($param_Array[$key], $param_ArrayValue[$key]);
+			} else {
+				$param_Array[$key] = $param_ArrayValue[$key];
+			}
+		}
+
+	}
+}
+?>

class_mcCrypt.inc.php

+<?
+
+class mcCrypt {
+	public static function crypt($param_string) {
+//		return crypt($param_string);
+		return hash('sha256' ,$param_string);
+	}
+}
+
+?>

class_mcDate.inc.php

+<?php
+class mcDate {
+	/**
+	 * check if the format is like this yyyy-mm-dd
+	 */
+	public static function check8601Date($param_date) {
+		$datumfalsch = 0;
+		$pruefjahr = substr($param_date, 0, 4);
+		$pruefstrich1 = substr($param_date, 4, 1);
+		$pruefmonat = substr($param_date, 5, 2);
+		$pruefstrich2 = substr($param_date, 7, 1);
+		$prueftag = substr($param_date, 8, 2);
+		
+		if (!eregi("^[0-9]+$", $pruefjahr))
+			$datumfalsch = 1;
+		if ($pruefstrich1 != "-")
+			$datumfalsch = 1;;
+		if ($pruefstrich2 != "-")
+			$datumfalsch = 1;;
+		if ($pruefmonat < 01 || $pruefmonat > 12)
+			$datumfalsch = 1;
+		if ($prueftag < 01)
+			$datumfalsch = 1;
+
+		if ($datumfalsch == 0 && !checkdate($pruefmonat, $prueftag, $pruefjahr)) {
+			$datumfalsch = 1;
+		}
+
+		if($datumfalsch==1) {
+			 return false;
+		} else {
+			return true;
+		}
+	}
+	/**
+	 * wants http://en.wikipedia.org/wiki/ISO_8601 format for a date
+	 */
+	public static function format8601Date($param_date) {
+		if($param_date == '0000-00-00') {
+			return '';
+		} else {
+			$pruefjahr = substr($param_date, 0, 4);
+			$pruefmonat = substr($param_date, 5, 2);
+			$prueftag = substr($param_date, 8, 2);
+			return $prueftag.'.'.$pruefmonat.'.'.$pruefjahr;
+		}
+	}
+
+	public static function checkIfFirstIsBefore($param_DateBefore, $param_DateAfter) {
+		if(mcDate::check8601Date($param_DateBefore) && mcDate::check8601Date($param_DateAfter)) {
+			$DateBefore_jahr = substr($param_DateBefore, 0, 4);
+			$DateBefore_monat = substr($param_DateBefore, 5, 2);
+			$DateBefore_tag = substr($param_DateBefore, 8, 2);
+			
+			$DateAfter_jahr = substr($param_DateAfter, 0, 4);
+			$DateAfter_monat = substr($param_DateAfter, 5, 2);
+			$DateAfter_tag = substr($param_DateAfter, 8, 2);
+
+
+			if($DateBefore_jahr <= $DateAfter_jahr
+					&& $DateBefore_monat <= $DateAfter_monat
+					&& $DateBefore_tag <= $DateAfter_tag) {
+				return true;
+			} else {
+				return false;
+			}
+
+		} else {
+			return false;
+		}
+
+	}
+}
+?>

class_mcNumber.inc.php

+<?php
+class mcNumber {
+	public static function form2($param_number) {
+		return number_format(round($param_number, 2), 2, ",", ".");
+	}
+}
+?>

class_mcString.inc.php

+<?php
+class mcString {
+	public static function generateAlphaNumericRandumString($param_length=8) {
+		$characters = array(
+			"A","B","C","D","E","F","G","H","J","K","L","M",
+			"N","P","Q","R","S","T","U","V","W","X","Y","Z",
+			"1","2","3","4","5","6","7","8","9"
+		);
+
+		$keys = array();
+
+		while(count($keys) < $param_length) {
+
+			$x = mt_rand(0, count($characters)-1);
+			if(!in_array($x, $keys)) {
+			   $keys[] = $x;
+			}
+		}
+
+		foreach($keys as $key){
+		   $random_chars .= $characters[$key];
+		}
+		return $random_chars;
+	}
+
+
+}
+?>

finance/class_mcZinsmethoden.inc.php

+<?php
+
+class mcZinsmethoden {
+	public static function rechneZinsen($evon, $ezdatum, $ebis, $emzins, $ezbetrag) {
+		global $__ZINSBERECHNUNG;
+		if($__ZINSBERECHNUNG == 'taggenau') {
+			$result = self::rechneZinsenTaggenau($evon, $ezdatum, $ebis, $emzins, $ezbetrag);
+		} else if($__ZINSBERECHNUNG == 'deutsch') {
+			$result = self::rechneZinsenDeutsch($evon, $ezdatum, $ebis, $emzins, $ezbetrag);
+		} else if($__ZINSBERECHNUNG == 'old') {
+			include ("../includes/zinsenrechnen.inc.php");
+			$result =  array('zinsbetrag' => $zinsbetrag, 'zinstage'=> $zinstage);
+		}
+
+		return $result;
+	}
+
+	private static function rechneTageDeutschMaxYear($start_month, $start_day, $stop_month, $stop_day, $year) {
+		$start_month = (int) $start_month;
+		$start_day = (int) $start_day;
+		$stop_month = (int) $stop_month;
+		$stop_day = (int) $stop_day;
+
+
+		if($start_month==1 && $start_day==1 && $stop_month==12 && $stop_day==31) {
+			$zinstage = self::$JahrTage_deutsch;
+		} else {
+			$monatstage = self::$Monatstage;
+			$zinstage = 0;
+			$schalt = $year % 4;
+			if ($schalt == 0) {
+				$schalt = true;
+				$monatstage[2] = 29;
+			} else {
+				$schalt = false;
+			}
+
+			for($month=$start_month; $month<=$stop_month; $month++) {
+				if($start_month == $stop_month) {
+					$zinstage = $stop_day - $start_day;
+
+				} else if($month == $start_month) {
+					if($start_day == 1) {
+						$zinstage = 30;
+					} else if($month == 2) {
+						$zinstage = 30 - $start_day;
+					} else {
+						$zinstage = $monatstage[$month] - $start_day;
+					}
+					D::ulli($zinstage . ' 1## '.$month. ' ########### '.$monatstage[$month]);
+				} else if($month == $stop_month) {
+					if($stop_day == 31) {
+						$zinstage = $zinstage + 30;
+					} else {
+						$zinstage = $zinstage + ($stop_day);
+					}
+					D::ulli($zinstage . ' 2## '.$month);
+				} else {
+
+					$zinstage = $zinstage + self::$MonatTage_deutsch;
+					D::ulli($zinstage . ' 3## '.$month);
+				}
+			}
+
+
+		}
+		D::li("$start_month, $start_day ==> $stop_month, $stop_day, $year ==== $zinstage" );
+		return $zinstage;
+	}
+
+	private static $JahrTage_deutsch = 360;
+	private static $MonatTage_deutsch = 30;
+
+
+	/**
+	 *		Deutsche kaufmännische Zinsrechnung	30/360
+	 *		Zinstage: Monat zu 30 Zinstagen
+	 *			(fällt Beginn oder Ende der Zinszahlungsfrist auden 31. eines
+	 *			Monats, wird dieser wie der 30. behandelt;
+	 *			endet Verzinsung Wert 28.02. (29.02.), werden Zinsen bis einschl.
+	 *			28.02. (29.02.) gerechnet;
+	 *			läuft Verzinsung über ultimo Februar hinaus, wird Februar mit 30
+	 *			Tagen gerechnet.)
+	 *		Jahr zu 360 Zinstagen
+	 *		Anwendnung:		Sparkonten
+	 *						Kunden-Festgeldkonten
+	 *						Kontokorrentkonten
+	 *						Ratenkredite
+	 *						langfristige Darlehen
+	 *
+	 * @param yyyy-mm-dd $evon
+	 * @param yyyy-mm-dd $ezdatum
+	 * @param yyyy-mm-dd $ebis
+	 * @param int $emzins
+	 * @param €€.cc $ezbetrag
+	 * @return array('zinsbetrag' => $zinsbetrag, 'zinstage'=> $zinstage);
+	 */
+	public static function rechneZinsenDeutsch($evon, $ezdatum, $ebis, $emzins, $ezbetrag) {
+		$jahrtage = self::$JahrTage_deutsch;
+		if ($evon < $ezdatum) {
+			$zinsdat1 = $ezdatum;
+		} else {
+			$zinsdat1=$evon;
+		}
+		$zinsdat2 = $ebis;
+		$zinsdat1tt = substr($zinsdat1, 8, 2);
+		$zinsdat1mm = substr($zinsdat1, 5, 2);
+		$zinsdat1jj = substr($zinsdat1, 0, 4);
+		$zinsdat2tt = substr($zinsdat2, 8, 2);
+		$zinsdat2mm = substr($zinsdat2, 5, 2);
+		$zinsdat2jj = substr($zinsdat2, 0, 4);
+
+		if($zinsdat1jj+1 < $zinsdat2jj) {
+			$fullyear = $zinsdat2jj - ($zinsdat1jj+1);
+			$zinstage = $fullyear * self::$JahrTage_deutsch;
+//			D::ulli('$fullyear = '.$fullyear. ' $zinstage = '.$zinstage);
+
+			$zinstage = $zinstage + self::rechneTageDeutschMaxYear($zinsdat1mm, $zinsdat1tt, 12, 31, $zinsdat1jj);
+//			D::ulli($zinstage. " =  + self::rechneTageDeutschMaxYear($zinsdat1mm, $zinsdat1tt, 12, 31, $zinsdat1jj)");
+			$zinstage = $zinstage + self::rechneTageDeutschMaxYear(1, 1, $zinsdat2mm, $zinsdat2tt, $zinsdat2jj);
+//			D::ulli($zinstage. " =  + self::rechneTageDeutschMaxYear(1, 1, $zinsdat2mm, $zinsdat2tt, $zinsdat2jj);");
+
+
+		} else if($zinsdat1jj+1 == $zinsdat2jj) {
+			$zinstage = self::rechneTageDeutschMaxYear($zinsdat1mm, $zinsdat1tt, 12, 31, $zinsdat1jj);
+//			D::ulli($zinstage. "  = self::rechneTageDeutschMaxYear($zinsdat1mm, $zinsdat1tt, 12, 31, $zinsdat1jj)");
+			$zinstage = $zinstage + self::rechneTageDeutschMaxYear(1, 1, $zinsdat2mm, $zinsdat2tt, $zinsdat2jj);
+//			D::ulli($zinstage. " =  + self::rechneTageDeutschMaxYear(1, 1, $zinsdat2mm, $zinsdat2tt, $zinsdat2jj);");
+
+		} else if($zinsdat1jj == $zinsdat2jj) {
+			$zinstage = self::rechneTageDeutschMaxYear($zinsdat1mm, $zinsdat1tt, $zinsdat2mm, $zinsdat2tt, $zinsdat2jj);
+		}
+
+
+
+		$zinsbetrag = self::rechneZins($emzins, $ezbetrag, $jahrtage, $zinstage);
+		return array('zinsbetrag' => $zinsbetrag, 'zinstage'=> $zinstage);
+	}
+
+	private static $Monatstage = array(
+		0	=>	'',
+		1	=>	31,
+		2	=>	28,
+		3	=>	31,
+		4	=>	30,
+		5	=>	31,
+		6	=>	30,
+		7	=>	31,
+		8	=>	31,
+		9	=>	30,
+		10	=>	31,
+		11	=>	30,
+		12	=>	31
+	);
+
+	/**
+	 *	Taggenaue Zinsrechnung	("englische Zinsrechnung")	act/act
+	 *		Zinstage kalendermäßig
+	 *		Jahr zu 365 bzw. 366 Zinstagen (lt.Kalender)
+	 *		Anwendung:	Bundesanleihen mit festem Zins
+	 *					Bundesobligationen
+	 *					Bundesschatzanweisungen
+	 *					Finanzierungsschätze
+	 *					Bundesschatzbriefe
+	 *					Börsennotierte Anleihen
+	 *					deutsche bürgerliche Zinsrechnung
+	 * @todo fnc berechnet nur Zinsen für ein Jahr
+	 *
+	 *
+	 * @param yyyy-mm-dd $evon
+	 * @param yyyy-mm-dd $ezdatum
+	 * @param yyyy-mm-dd $ebis
+	 * @param <type> $emzins
+	 * @param <type> $ezbetrag
+	 * @return  array('zinsbetrag' => $zinsbetrag, 'zinstage'=> $zinstage);
+	 */
+	public static function rechneZinsenTaggenau($evon, $ezdatum, $ebis, $emzins, $ezbetrag) {
+		$monatstage[0] = "";
+		$monatstage[1] = 31;
+		$monatstage[2] = 28;
+		$monatstage[3] = 31;
+		$monatstage[4] = 30;
+		$monatstage[5] = 31;
+		$monatstage[6] = 30;
+		$monatstage[7] = 31;
+		$monatstage[8] = 31;
+		$monatstage[9] = 30;
+		$monatstage[10] = 31;
+		$monatstage[11] = 30;
+		$monatstage[12] = 31;
+		$anzmon = 13;
+		$zinstage = 0;
+		$zinsbetrag = 0;
+
+		if ($evon < $ezdatum)
+			$zinsdat1 = $ezdatum;
+		else
+			$zinsdat1=$evon;
+
+		$zinsdat2 = $ebis;
+		$zinsdat1tt = substr($zinsdat1, 8, 2);
+		$zinsdat1mm = substr($zinsdat1, 5, 2);
+		$zinsdat1jj = substr($zinsdat1, 0, 4);
+		$zinsdat2tt = substr($zinsdat2, 8, 2);
+		$zinsdat2mm = substr($zinsdat2, 5, 2);
+		$zinsdat2jj = substr($zinsdat2, 0, 4);
+		$zinstage = 0;
+		$schalt = $zinsdat1jj % 4;
+		if ($schalt == 0) {
+			$jahrtage = 366;
+			$monatstage[2] = 29;
+		} else {
+			$jahrtage = 365;
+			$monatstage[2] = 28;
+		}
+		$j = 0 + $zinsdat1mm;
+		$monatanfang = $monatstage[$j] - $zinsdat1tt + 1;
+
+		$j = 0 + $zinsdat2mm;
+		$monatende = $zinsdat2tt;
+		if ($zinsdat1mm == $zinsdat2mm)
+			$monatende = 0;
+		$anfang = $zinsdat1mm + 1;
+		$ende = $zinsdat2mm;
+		for ($j = $anfang; $j < $ende; $j++) {
+			$mmtag = $monatstage[$j];
+			$zinstage = $zinstage + $mmtag;
+		}
+		$zinstage = $zinstage + $monatanfang + $monatende;
+
+		$zinsbetrag = self::rechneZins($emzins, $ezbetrag, $jahrtage, $zinstage);
+
+		return array('zinsbetrag' => $zinsbetrag, 'zinstage'=> $zinstage);
+	}
+
+	private static function rechneZins($emzins, $ezbetrag, $jahrtage, $zinstage) {
+		$zinsbetrag = 0;
+		if ($emzins != 0) {
+			$tagbetrag = ($ezbetrag / $jahrtage) * $zinstage;
+			$rechbetrag = ($tagbetrag * $emzins) / 100;
+			$zinsbetrag = round($rechbetrag, 2);
+
+		}
+		return $zinsbetrag;
+	}
+}
+
+?>
\ No newline at end of file

phpunit/basepath.inc.php

+<?php
+/**
+ * @var link to the basic path from the basic dir
+ */
+$__BASEPATH_EX= './';
+
+
+?>
\ No newline at end of file

phpunit/class_mcArray_PHPTest.inc.php

+<?php
+//require_once 'PHPUnit/Framework.php';
+require_once 'basepath.inc.php';
+
+require_once $__BASEPATH_EX . '../class_mcArray.inc.php';
+
+/**
+ * Test class for DBUIHelpers_PHP.
+ * Generated by PHPUnit on 2010-07-13 at 14:12:12.
+ */
+class mcArray_PHPTest extends PHPUnit_Framework_TestCase {
+
+	/**
+	 * Sets up the fixture, for example, opens a network connection.
+	 * This method is called before a test is executed.
+	 */
+	protected function setUp() {
+
+	}
+
+	/**
+	 * Tears down the fixture, for example, closes a network connection.
+	 * This method is called after a test is executed.
+	 */
+	protected function tearDown() {
+
+	}
+
+
+	public function test_addArrayValueToArray() {
+
+		//
+		$Array = array();
+		$addArrayValue = array( 
+			'key_r1' => array(
+				'key_r2' => array(
+					'key_r3_a' => 'value'
+					)
+				)
+			);
+		mcArray::addArrayValueToArray($Array, $addArrayValue);
+		$this->assertEquals($Array, $addArrayValue);
+
+
+		//
+		// $Array = $addArrayValue
+		$addArrayValue2 = array( 
+			'key_r1' => array(
+				'key_r2' => array(
+					'key_r3_b' => 'value'
+					)
+				)
+			);
+		mcArray::addArrayValueToArray($Array, $addArrayValue2);
+		$result_array2 = array(
+			'key_r1' => array(
+				'key_r2' => array(
+					'key_r3_a' => 'value',
+					'key_r3_b' => 'value'
+					)
+				)
+			);
+		$this->assertEquals($Array, $result_array2);
+
+
+		//	$Array = $result_array2
+		$addArrayValue3 = array(
+			'key_r1' => array(
+				'key_r2_b' => array(
+					'key_r3_b' => 'value'
+					)
+				)
+			);
+		mcArray::addArrayValueToArray($Array, $addArrayValue3);
+		$result_array3 = array(
+			'key_r1' => array(
+				'key_r2' => array(
+					'key_r3_a' => 'value',
+					'key_r3_b' => 'value'
+					),
+				'key_r2_b' => array(
+					'key_r3_b' => 'value'
+					)
+				)
+			);
+		$this->assertEquals($Array, $result_array3);
+
+
+		//
+		$addArrayValue4 = array(
+			'key_r1' => array(
+				'key_r2' => array(
+					'key_r3_c' => 'value',
+					'key_r3_d' => 'value'
+					),
+				'key_r2_b' => array(
+					'key_r3_c' => array('value')
+					)
+				)
+			);
+		mcArray::addArrayValueToArray($Array, $addArrayValue4);
+		$result_array4 = array(
+			'key_r1' => array(
+				'key_r2' => array(
+					'key_r3_a' => 'value',
+					'key_r3_b' => 'value',
+					'key_r3_c' => 'value',
+					'key_r3_d' => 'value'
+					),
+				'key_r2_b' => array(
+					'key_r3_b' => 'value',
+					'key_r3_c' => array('value')
+					)
+				)
+			);
+		$this->assertEquals($Array, $result_array4);
+
+print_r($Array);
+
+
+	}
+
+
+
+}
+
+?>