polyfony-inc / polyfony Goto Github PK

// close all sessions
Pf\Database::query()
    ->update('Accounts')
    ->set(array(
        'session_expiration_date'   =>null,
        'session_key'               =>null,
        'last_login_origin'         =>null,
        'last_login_agent'          =>null,
        'last_login_date'           =>null,
        'last_failure_origin'       =>null,
        'last_failure_agent'        =>null,
        'last_failure_date'         =>null,
    ))
    ->execute();

    // secure a column name
    private function secure($column, $full_escape=false) {
        // full escape means that even dots will be escaped (usefull for joins parameters)
        $regex = $full_escape ? '/[^a-zA-Z0-9_]/' : '/[^a-zA-Z0-9_\.]/';
        // apply the regex
        $column = preg_replace($regex, '', $column);    
        // return cleaned column
        return($column);
    }

// add a condition
    public function where($conditions) {
        // if provided conditions are an array
        if(is_array($conditions)) {
            // for each provided strict condition
            foreach($conditions as $column => $value) {
                // if the column name not numeric
                if(!is_numeric($column)) {
                    // secure the column name
                    $column = $this->secure($column);
                    // if the operator is missing
                    if(!$this->Operator) {
                        // force AND operator
                        $this->Operator = 'AND';
                    }
                    // save the condition
                    $this->Conditions[] = "{$this->Operator} ( {$column} = :{$this->secure($column,true)} )";
                    // save the value
                    $this->Values[":{$this->secure($column,true)}"] = $value;
                }
                // column name in a number
                else {
                    // throw an exception
                    Throw new Exception('giQuery->where() : Column name cannot be a number');
                }
            }
        }
        // return self to the next method
        return($this);
    }

$filesystem = new Filesystem();

$filesystem->copy($originFile, $targetFile, $override = false);

$filesystem->mkdir($dirs, $mode = 0777);

$filesystem->touch($files, $time = null, $atime = null);

$filesystem->remove($files);

$filesystem->exists($files);

$filesystem->chmod($files, $mode, $umask = 0000, $recursive = false);

$filesystem->chown($files, $user, $recursive = false);

$filesystem->chgrp($files, $group, $recursive = false);

$filesystem->rename($origin, $target);

$filesystem->symlink($originDir, $targetDir, $copyOnWindows = false);

$filesystem->makePathRelative($endPath, $startPath);

$filesystem->mirror($originDir, $targetDir, \Traversable $iterator = null, $options = array());

$filesystem->isAbsolutePath($file);

$mail = new Mail($template=null);
$mail
->to
->cc
->bcc
->subject
->set($var,$value)
->send();

function set($var, $value, $escape=false) {
$value = $escape ? Format::htmlSafe($value) : $value;
str_replace("__{$var}__", $value , $template);
}

$newDate = DateTime::createFromFormat("l dS F Y", $dateFromDB);
$newDate = $newDate->format('d/m/Y'); // for example

// ...
public function createAction()
{
    $product = new Product();
    $product->setName('A Foo Bar');
    $product->setPrice('19.99');
    $product->setDescription('Lorem ipsum dolor');

    $em = $this->getDoctrine()->getManager();

    $em->persist($product);
    $em->flush();

    return new Response('Created product id '.$product->getId());
}

// create a record object
$product = new pfRecord($table);
// alter something
$product->set('description','Marvellous tool !');
// this will insert the record for the first time
$product->save();

// fetch a product from the database by its id
$product = new pfRecord($table,$id);
// alter something
$product->set('description','Marvellous tool !');
// this will update the product currently in the database
$product->save();

                list($this->Table) = explode(' ',$table);
            }
            // in case of DELETE or SELECT
            elseif($action == 'DELETE' or $action == 'SELECT') {
                // explode after FROM 
                list($null,$table) = explode('FROM ',$this->Query);
                // isolate the table name
                list($this->Table) = explode(' ',$table);
            }
            // clean the table name from any quotes
            $this->Table = trim($this->Table,'\'/"`');

    }

}


?>

// cookie
// session
// database (table/blob)
// filesystem
// memcache
// apc
// request (volatile)

interface StorageInterface
{
    /**
     * Check whether the variable exists in the store.
     *
     * @access public
     * @param  string  $variable The name of the variable to check existence of.
     * @return boolean           If the variable exists or not.
     */
    public static function has($variable);
    /**
     * Store a variable for use.
     *
     * @access public
     * @param  string  $variable  The name of the variable to store.
     * @param  mixed   $value     The data we wish to store.
     * @param  boolean $overwrite Whether we are allowed to overwrite the variable.
     * @return boolean            If we managed to store the variable.
     */
    public static function put($variable, $value, $overwrite);
    /**
     * Return the variable's value from the store.
     *
     * @access public
     * @param  string $variable The name of the variable in the store.
     * @return mixed
     */
    public static function get($variable);
    /**
     * Remove the variable in the store.
     *
     * @access public
     * @param  string $variable The name of the variable to remove.
     * @return boolean          If the variable was removed successfully.
     */
    public static function remove($variable);
}

../Private/Bundles/Name/
../Private/Bundles/Name/Loader/Route.php
../Private/Bundles/Name/Controller/TableController.php // with sanitisation and notice object
    indexAction()
    createAction()
    editAction()
    deleteAction()
    updateAction()
../Private/Bundles/Name/Views/Table.php
../Private/Bundles/Name/Views/TableCreate.php
../Private/Bundles/Name/Views/TableEdit.php

if ('cli' !== php_sapi_name())

$flags = FilesystemIterator::KEY_AS_PATHNAME | FilesystemIterator::CURRENT_AS_FILEINFO | FilesystemIterator::SKIP_DOTS | FilesystemIterator::UNIX_PATHS;
        $d_iterator = new RecursiveDirectoryIterator($folder, $flags);

        echo $d_iterator->getPath();

$query->where(array('id'=>'1',is_enabled''=>'1'));
$query->where('id',1);

    // init the response
    public static function init() {

        // check if we can render a response from the cache
        self::isCached() == false ?: self::renderFromCache();
        // start the output buffer
        ob_start();
        // set default assets
        self::$_assets = array(
            // as empty arrays

/**
     * Another test function
     *
     * First parameter must be an array
     */
    public function test_array(array $input_array) {
        print_r($input_array);
    }

if(pf\Request::isPost()) {
    foreach(pf\Request::post('Affairs') as $column => $value) {
        $this->affair->set($column, $value);
    }
}

if(pf\Request::isPost()) {
    $this->affair->set(pf\Request::post('Affairs'));
}

                $sendmail = sprintf('%s -oi -t', escapeshellcmd($this->Sendmail));
            }
        }
        if ($this->SingleTo === true) {
            foreach ($this->SingleToArray as $toAddr) {
                if (!@$mail = popen($sendmail, 'w')) {
                    throw new \Polyfony\Exception($this->lang('execute') . $this->Sendmail, self::STOP_CRITICAL);
                }
                fputs($mail, 'To: ' . $toAddr . "\n");
                fputs($mail, $header);
                fputs($mail, $body);

Config::set()

        if(!file_exists($script)) {
            // new polyfony exception
            Throw new Exception("Dispatcher::forward() : Missing controller file [{$script}]",500); 
        }
        // include the controller's file
        require_once($script);
        // if class is missing from the controller and not in error route
        if(!class_exists($class,false)) {
            // new polyfony exception
            Throw new Exception("Dispatcher::forward() : Missing controller class [{$class}] in [{$script}]",500);  
        }

echo $record->get('ultimatum_datetime');

        }

        return ($url);
    }

    public static function forward($route) {

        // set full controller
        $script = "../Private/Bundles/{$route->bundle}/Controllers/{$route->controller}.php";
        // set the full class
        $class = "{$route->controller}Controller";

            $subject = $this->secureHeader($subject);
        } else {
            $subject = $this->encodeHeader($this->secureHeader($subject));
        }
        if (ini_get('safe_mode') || !($this->UseSendmailOptions)) {
            $result = @mail($to, $subject, $body, $header);
        } else {
            $result = @mail($to, $subject, $body, $header, $params);
        }
        return $result;
    }

            return '';
        }
        if (empty($phrase)) {
        return $text;
        }
        if (is_array($phrase) or ($phrase instanceof sfOutputEscaperArrayDecorator)) {
            foreach ($phrase as $word) {
                $pattern[] = '/('.preg_quote($word, '/').')/i';
                $replacement[] = $highlighter;
            }
        }

$camelized = $this->camelize($property);
        $reflClass = new \ReflectionClass($object);
        $getter = 'get'.$camelized;
        $getsetter = lcfirst($camelized); // jQuery style, e.g. read: last(), write: last($item)
        $isser = 'is'.$camelized;
        $hasser = 'has'.$camelized;
        $classHasProperty = $reflClass->hasProperty($property);
        if ($reflClass->hasMethod($getter) && $reflClass->getMethod($getter)->isPublic()) {
            $result[self::VALUE] = $object->$getter();
        } elseif ($this->isMethodAccessible($reflClass, $getsetter, 0)) {
            $result[self::VALUE] = $object->$getsetter();
        } elseif ($reflClass->hasMethod($isser) && $reflClass->getMethod($isser)->isPublic()) {
            $result[self::VALUE] = $object->$isser();
        } elseif ($reflClass->hasMethod($hasser) && $reflClass->getMethod($hasser)->isPublic()) {
            $result[self::VALUE] = $object->$hasser();
        } elseif ($reflClass->hasMethod('__get') && $reflClass->getMethod('__get')->isPublic()) {
            $result[self::VALUE] = $object->$property;
        } elseif ($classHasProperty && $reflClass->getProperty($property)->isPublic()) {
            $result[self::VALUE] = & $object->$property;
            $result[self::IS_REF] = true;
        } elseif (!$classHasProperty && property_exists($object, $property)) {
            // Needed to support \stdClass instances. We need to explicitly
            // exclude $classHasProperty, otherwise if in the previous clause
            // a *protected* property was found on the class, property_exists()
            // returns true, consequently the following line will result in a
            // fatal error.
            $result[self::VALUE] = & $object->$property;
            $result[self::IS_REF] = true;
        } elseif ($this->magicCall && $reflClass->hasMethod('__call') && $reflClass->getMethod('__call')->isPublic()) {
            // we call the getter and hope the __call do the job
            $result[self::VALUE] = $object->$getter();
        } else {
            $methods = array($getter, $getsetter, $isser, $hasser, '__get');
            if ($this->magicCall) {
                $methods[] = '__call';
            }

$input = new HTML\Element::input();

$element = new HTML\Element('div')
->setText()
->setHtml()
->setAttribute()
->setClass
->setId
->addEvent()
…
__toString 

types: div, span, optgroup…

$this->Notice = $this->Success ? 
    new Notice\Success('Qualification réussie') : 
    new Notice\Error('Echec');

// to display the notice elsewhere
Polyfony\Store\Request::put('notice',$this->Notice); 

    }

    // set the destination for that route
    public function destination($bundle, $controller=null, $action=null) {
        $this->bundle = $bundle;
        $this->controller = $controller != null ? $controller : 'Index';
        $this->action = $action != null ? $action : null;
        return $this;
    }
}

        // apply the chmod
        return(chmod($path, $mask));

    }

    public static function chown($path, $user, $override_chroot = false) {

        // if chroot is enabled, restrict the path to the chroot
        $path = self::chroot($path, $override_chroot);

    }

            header("{$header_key}: {$header_value}");       
        }
        // if the type is file output from the file indicated as content else just output
        echo self::getContent();
        // if cache is enabled and page is cachable
        self::isCachable() == false ?: self::cache(); 
        // it ends here
        exit;

    }