Beiträge von cottton

class CallBack
{
    private static
        $ready,
        $callonready;




    final public static function is_ready($called_class=null)
    {
        $cc = ($called_class)
            ?$called_class
            :get_called_class();




        return (isset(self::$ready[$cc])and self::$ready[$cc] === true);
    }
    final public static function register($classname=null,$function,$para=null)
    {
        $cc = get_called_class();




        self::$callonready[$cc][] = array(
            'class' => $classname,
            'func' => $function,
            'para' => $para,
        );
        # if already ready -> call registered:
        if(self::is_ready($cc)){
            self::execRegistered($cc);
        }
        return;
    }
    final protected static function execRegistered($called_class=null)
    {
        $cc = ($called_class)
            ?$called_class
            :get_called_class();




        self::$ready[$cc] = true;




        if(isset(self::$callonready[$cc])and is_array(self::$callonready[$cc])and !empty(self::$callonready[$cc])){
            foreach(self::$callonready[$cc] as $key => $call){
                if($call['class']){
                    call_user_func_array(
                        array($call['class'],$call['func']),
                        ($call['para'])
                            ?array($call['para'])
                            :array()
                    );
                }else{
                    call_user_func(
                        $call['func'],
                        ($call['para'])
                            ?$call['para']
                            :array()
                    );
                }
                unset(self::$callonready[$cc][$key]);
            }
        }
        return;
    }
}




class Sql extends CallBack
{
    public static function connect()
    {
        # after connecting *whatEva*
        echo '<br>i am at '.__METHOD__.'(), just connected and gona execute possibly registered ... (this means i am ready now)';
        self::execRegistered();
        return;
    }
    public static function doSomething()
    {
        if(Something::is_ready() === true){
            echo '<br>i am at '.__METHOD__.'() and Something::is_ready() === true -- Something called me back!';
        }else{
            echo '<br>i am at '.__METHOD__.'() and tried to call Something. But Something::is_ready() !== true -- is not ready :(';
            Something::register(__CLASS__,__METHOD__,null);
            echo '<br>so i ('.__METHOD__.'()) just registered at class Something -- waiting for a call back!';
        }
        return;
    }
}




class Something extends CallBack
{
    public static function loadnMyOwnSh1t()
    {
        # after loading *whatEva*
        echo '<br>i am at '.__METHOD__.'(), loaded my sh1t and gona execute possibly registered ... (this means i am ready now)';
        self::execRegistered();
        return;
    }
    public static function printMeThatString($str=null)
    {
        if(Sql::is_ready() === true){
            echo '<br>i am at '.__METHOD__.'() and Sql::is_ready() === true -- Sql called me back!';
            echo '<br>by the way: i ('.__METHOD__.'()) got the parameter `'.$str.'` from Sql =)';
            self::loadnMyOwnSh1t();
        }else{
            echo '<br>i am at '.__METHOD__.'() and tried to call Sql. But Sql::is_ready() !== true -- is not ready :(';
            Sql::register(__CLASS__,__METHOD__,$str);
            echo '<br>so i ('.__METHOD__.'()) just registered at class Sql -- waiting for a call back!';
        }
        return;
    }
    public static function printMeThatArray($arr=null)
    {
        if(Sql::is_ready() === true){
            echo '<br>i am at '.__METHOD__.'() and Sql::is_ready() === true -- Sql called me back!';
            echo '<br>by the way: i ('.__METHOD__.'()) got the parameter `'.implode('`, `',$arr).'` from Sql =)';
        }else{
            echo '<br>i am at '.__METHOD__.'() and tried to call Sql. But Sql::is_ready() !== true -- is not ready :(';
            Sql::register(__CLASS__,__METHOD__,$arr);
            echo '<br>so i ('.__METHOD__.'()) just registered at class Sql -- waiting for a call back!';
        }
        return;
    }
}




Sql::doSomething();
echo '<hr>';
Something::printMeThatString('my parameter value');
echo '<hr>';
Something::printMeThatArray(array(0=>'1st string',1=>'2nd string'));
echo '<hr>';
Sql::connect();




/* OUTPUT:







i am at Sql::doSomething() and tried to call Something. But Something::is_ready() !== true -- is not ready :(
so i (Sql::doSomething()) just registered at class Something -- waiting for a call back!




i am at Something::printMeThatString() and tried to call Sql. But Sql::is_ready() !== true -- is not ready :(
so i (Something::printMeThatString()) just registered at class Sql -- waiting for a call back!




i am at Something::printMeThatArray() and tried to call Sql. But Sql::is_ready() !== true -- is not ready :(
so i (Something::printMeThatArray()) just registered at class Sql -- waiting for a call back!




i am at Sql::connect(), just connected and gona execute possibly registered ... (this means i am ready now)
i am at Something::printMeThatString() and Sql::is_ready() === true -- Sql called me back!
by the way: i (Something::printMeThatString()) got the parameter `my parameter value` from Sql =)
i am at Something::loadnMyOwnSh1t(), loaded my sh1t and gona execute possibly registered ... (this means i am ready now)
i am at Sql::doSomething() and Something::is_ready() === true -- Something called me back!
i am at Something::printMeThatArray() and Sql::is_ready() === true -- Sql called me back!
by the way: i (Something::printMeThatArray()) got the parameter `1st string`, `2nd string` from Sql =)




*/

const POSITION_KEY = 0;
const POSITION_VAL = 2;
const POSITION_DESC = 1;




$key = 'key';
$val = 'val';
$desc = 'desc';







$arr = array(
    POSITION_KEY => $key,
    POSITION_VAL => $val,
    POSITION_DESC => $desc,
);
echo kimplode('=',$arr); // key=desc=val
echo '<br>';
echo krimplode('=',$arr); // val=desc=key







function kimplode($glue,$arr){
    ksort($arr);
    return implode($glue,$arr);
}
function krimplode($glue,$arr){
    krsort($arr);
    return implode($glue,$arr);
}

/*interval setzen*/
var waitabit = setInterval(
    function(){
        if(boxconfig){ /*wenn boxconfig existiert*/
            clearInterval(waitabit); /*dann könn wa aufhören zu prüfen ... */
            /*... und die alert-func laden:*/
            loadAlert(/*evtl boxconfig mitgeben?*/)
        }
    },
    20 /*aller 20 mille prüfen*/
);
loadAlert(){
    /*hier den kompletten code für die alert func
    weiß aber net, ob das wirklich funzt
    würde dann eher eine klasse bevorzugen =)*/
}

class Mensch
{
    const ANZAHL_AUGEN = 2;




    public function gibAnzahlAugen()
    {
        echo 'Mensch hat '.self::ANZAHL_AUGEN.' Auge(n)<br>'; // 2
    }
}




class Mann extends Mensch
{
    const ANZAHL_AUGEN = 2;




    public function gibAnzahlAugen()
    {
        echo 'Mann hat '.self::ANZAHL_AUGEN.' Auge(n)<br>'; // 2
        echo 'sowie ein Mensch '.parent::ANZAHL_AUGEN.' Auge(n) hat<br>'; // 2
    }
}




class EinAuge extends Mann
{
    const ANZAHL_AUGEN = 1;




    public function gibAnzahlAugen()
    {
        echo 'EinAuge hat '.self::ANZAHL_AUGEN.' Auge(n)<br>'; // 1
        echo 'aber normalerweise hat ein Mann '.parent::ANZAHL_AUGEN.' Auge(n)<br>'; // 2
        echo 'sowie ein Mensch '.Mensch::ANZAHL_AUGEN.' Auge(n) hat<br>'; // 2
    }
}




$person = new EinAuge();
$person->gibAnzahlAugen();

<?php




session_start();
#session_destroy();




function html_($str){
    return htmlspecialchars($str);
}
class ErrorHandler
{
    # your e-handler
    public static function stop($str)
    {
        die($str);
    }
}
class FormGuard
{
    const SESSIONKEY_MAIN                   = 'formguard';
    const SESSIONKEY_UNIQUE_STR             = 'uniquestr';
    const SESSIONKEY_UNIQUE_FORMID_EXPECTED = 'uniquefidexp';
    const SESSIONKEY_UNIQUE_FORMID_NEXT     = 'uniquefidnex';
    const FORM_HIDDENFIELD_NAME             = 'formid';




    private static
        $uniqueformid,
        $uniquestring,
        $skips,
        $initialized;




    public static function init()
    {
        if(!isset($_SESSION)){
            ErrorHandler::stop('$_SESSION not started! @'.__METHOD__.'()');
        }
        if(self::$initialized){
            return;
        }
        # sort session:
        if(self::getSession(self::SESSIONKEY_UNIQUE_FORMID_NEXT)){
            self::setSession(
                self::SESSIONKEY_UNIQUE_FORMID_EXPECTED,
                self::getSession(self::SESSIONKEY_UNIQUE_FORMID_NEXT)
            );
            self::setSession(self::SESSIONKEY_UNIQUE_FORMID_NEXT,null);
        }
        # create unique form id:
        self::$uniqueformid = self::oneWayEncode(microtime(true));




        self::$initialized = true;
        return;
    }
    public static function getHiddenField()
    {
        self::init();
        self::setSession(self::SESSIONKEY_UNIQUE_FORMID_NEXT,self::$uniqueformid);
        return '<input
            type="hidden"
            name="'.html_(self::FORM_HIDDENFIELD_NAME).'"
            value="'.html_(self::$uniqueformid).'"
        />';
    }
    public static function justSubmitted()
    {
        self::init();
        self::setSession(self::SESSIONKEY_UNIQUE_STR,self::getUniqueString());
        return;
    }
    public static function check()
    {
        self::init();
        if(self::getSession(self::SESSIONKEY_UNIQUE_STR)or !self::is_expectedFormId()){
            if(self::getUniqueString() == self::getSession(self::SESSIONKEY_UNIQUE_STR)or !self::is_expectedFormId()){
                self::unsetByRef($_GET);
                self::unsetByRef($_POST);
                return false;
            }
        }
        return true;
    }
    public static function addSkips($arr)
    {
        self::init();
        $arr = (!is_array($arr))
            ?array($arr)
            :$arr;
        foreach($arr as $skip){
            self::$skips[] = $skip;
        }
        return;
    }
    public static function delSkips($arr)
    {
        self::init();
        $arr = (!is_array($arr))
            ?array($arr)
            :$arr;
        foreach($arr as $del){
            foreach(self::$skips as $key => $val){
                if($del == $val){
                    unset(self::$skips[$key]);
                }
            }
        }
        return;
    }
    private static function unsetByRef(&$that)
    {
        if(isset($that)and is_array($that)){
            foreach($that as $key => $val){
                if(empty(self::$skips)or !in_array($key,self::$skips)){
                    unset($that[$key]);
                }
            }
        }
        return;
    }
    private static function setSession($key,$val)
    {
        $_SESSION[self::SESSIONKEY_MAIN][$key] = $val;
        return;
    }
    private static function getSession($key)
    {
        return (isset($_SESSION[self::SESSIONKEY_MAIN][$key]))
            ?$_SESSION[self::SESSIONKEY_MAIN][$key]
            :false;
    }
    private static function getUniqueString()
    {
        if(!isset(self::$uniquestring)or empty(self::$uniquestring)){
            self::createUniqueString();
        }
        return self::$uniquestring;
    }
    private static function createUniqueString()
    {
        self::$uniquestring = (!isset(self::$uniquestring)or empty(self::$uniquestring))
            ?self::oneWayEncode(json_encode($_GET).json_encode($_POST))
            :self::$uniquestring;
        return;
    }
    private static function is_expectedFormId()
    {
        $expected_formid = (isset($_POST[self::FORM_HIDDENFIELD_NAME]))
            ?$_POST[self::FORM_HIDDENFIELD_NAME]
            :false;
        return (
            $expected_formid
            and (
                !self::getSession(self::SESSIONKEY_UNIQUE_FORMID_EXPECTED)
                or self::getSession(self::SESSIONKEY_UNIQUE_FORMID_EXPECTED) != $expected_formid
            )
        )
            ?false
            :true;
    }
    private static function oneWayEncode($str)
    {
        return sha1($str);
    }
}







###
# add formguard skips: this GET/POST keys wont be unset
#
FormGuard::addSkips(
    array('textfield1')
);







###
# let the formguard check the incomming GET/POST (always before you execute any requeste action!)
#
if(!FormGuard::check()){
    $msg = 'Hello, I am the FormGuard. You just sent a now invalid form. '.
        'I have allowed myself to ignore this one. (Possibly the session just has been expired)';
}







###
# somewhere in the script you wanna check if the form was submitted
# if so, and you executed the requested action,
# use FormGuard::justSubmitted(); to tell the formguard that this form is "done"
#
if(isset($_POST['sub'])){ # submit was pushed
    FormGuard::justSubmitted(); # hey formguard - dont let this form come in again =)
    $executed = true;
}
?>
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
    <head>
        <meta charset="utf8" />
        <title>FormGuard Test</title>
        <!-- cottton @i-stats.net [TS3: i-stats.net] -->
    </head>
    <body>
        <h1>FormGuard Test</h1>
        <p>Submit that form and then try to submit it agani by using F5 =)</p>
        <?php echo (isset($msg))?$msg:''; ?>
        <form name="form" action="" method="POST" enctype="application/x-www-form-urlencoded">
            <?php echo FormGuard::getHiddenField(); ?>
            <input type="text" name="textfield1" value="" placeholder="textfield1" />
            <input type="text" name="textfield2" value="" placeholder="textfield2" />
            <input type="text" name="textfield3" value="" placeholder="textfield3" />
            <input type="submit" name="sub" value="submit" />
        </form>
        <?php echo (isset($executed))?'Form executed':''; ?>
        <hr>
        <h2>Debug:</h2>
        <b>$_POST:</b>
        <pre><?php print_r($_POST); ?></pre>
        <b>$_GET:</b>
        <pre><?php print_r($_GET); ?></pre>
        <b>$_SESSION:</b>
        <pre><?php print_r($_SESSION); ?></pre>
    </body>
</html>

$sql = "
    -- this is my pretty commented query ...
    -- above comments works
    INSERT INTO
        `testdb`.`tbl`
    SET
        `name` = 'a' -- middle comment works
        -- `name` = 'a' middle new line comments works
    ; -- but this comment finally f* it up
    -- so simple nothing is allowed after the ;
    -- except if we destroy the stmt
";

$whitelist = array(
    'id','name','tag','ende','zeit','time','wieAuchImmerDeineSpaltenHeißen'
);




# dyn array:
$array = array(
    'name' => 'Wolf',
    'tag' => '13.4.2014',
    'ende' => '99.99.9999',
    'id' => 1221,
    'zeit' => 1111111,
    'time' => 1111111,
    'wieAuchImmerDeineSpaltenHeißen' => 1111111,
);




# create query cols, placeholder and paras dyn:
$i = 'a';
foreach($array as $col => $val){
    if(!in_array($col,$whitelist)){
        # stop!
        die('falsche col ... e-msg');
    }
    $columns[] = $col;
    $placeholder[] = $i;
    $parameter[$i] = $val;
    $i++;
}




$sql = "
    UPDATE
        `db`.`tbl´
    (´".implode('`, `',$columns)."´)
    VALUES (:".implode(', :',$placeholder).")
    WHERE
        `userid` = :userid
";
# need the :userid @paras:
$parameter['userid'] = 21321;




# output:
echo '<pre>Query: '.$sql.'<br>';
print_r($parameter);




# execute ...
// $stmt = $dbh->prepare($sql);
// $stmt->execute($parameter);

INSERT INTO
    `kunde`
SET
    `vorname` = '...', 
    `nachname` = '...'
    -- ect ect 
WHERE
    `idkunde` = ...
ON DUPLICATE KEY UPDATE
    `...` = '...', 
    `...` = '...'