<form action="/uploadme" method="post" enctype="multipart/form-data" name="upload-photo">
 <input name="profile_pic" type="file" />
 <input type="submit" value="submit"/>
</form>

In Controller, create an instance of DooGdImage, along with the upload/source path and the path to save your resized pictures:

 Doo::loadHelper('DooGdImage');
 //upload/source path, and output saved path
 $gd = new DooGdImage('/var/www/uploaded/', '/var/www/resized_pic/');

Call uploadImage() to save the uploaded file with a new name. The example below save the picture with the date as file name, img_20100104203245.jpg

$uploadImg = $gd->uploadImage('profile_pic', 'img_' .date('Ymdhis'));

Before your resize the picture, you can set the quality, generated image type and file name suffix (optional)

 $gd->generatedQuality = 85;
 $uploadImage->generatedType="jpg";

 //This thumbnail is 46x46 pixels, resize adaptively (perfect 46x46 crop from center)
 //Pic name is img_201001011200_46x46.jpg
 $gd->thumbSuffix = '_46x46';
 $gd->adaptiveResize($uploadImg,46,46);

You can use createThumb/createSquare to resize the pictures too.

 //Resize propotionally (so will not be perfect 75x75 depends on the image ratio, no cropping done)
 //Pic name is img_201001011200_75x75.jpg
 $gd->thumbSuffix = '_75x75';
 $gd->createThumb($uploadImg, 75, 75);

Some updates*

You can validate if the uploaded images meet your requirements by using checkImageType(), checkImageSize() and checkImageExtension()

• checkImageType() – check if image mime type is in the allowed list. Default: JPEGs, GIFs and PNGs
• checkImageExtension() – check if image file extension is in the allowed list.

Performance profiling can be used to measure the time & memory needed for the specified code blocks and find out what the performance bottleneck is. Instead of calling log() you change it to beginProfile() and endProfile(). We need to mark the beginning and the end of each code block by inserting the following methods:

Doo::logger()->beginProfile('block_id_here');
//...everything here will be profiled
Doo::logger()->endProfile('block_id_here');

Code blocks need to be nested properly. A code block cannot intersect with another. It must be either at a parallel level or be completely enclosed by the other code block.

All of the profiled results can be organized in category, simply pass in another parameter at the end of the method beginProfile():

//default category is 'application'
Doo::logger()->beginProfile('id', 'editpost');
//...everything here will be profiled
Doo::logger()->endProfile('id');

To retrieve the profiled results, you called getProfileResult(). You have to pass in the block ID as parameter and you will get an associative array which shows you the time and memory used when processing the code block.

Doo::logger()->beginProfile('block_id');
//...everything here will be profiled
Doo::logger()->endProfile('block_id');
$result = Doo::logger()->getProfileResult('block_id');

To view the profiled results, you just have to call showLogs(). By default it will return a neatly

There are a few methods in this file where you can use for profiling and logging queries or important message in your application. You can log a message by calling:

Doo::logger()->log('Something fishy here!', DooLog::Alert);

Or you can use the Alias methods instead of passing the log level:

Doo::logger()->alert('Something fishy here!');
Doo::logger()->emerg('message...');
Doo::logger()->crit('message...');
Doo::logger()->err('message...');
Doo::logger()->warn('message...');
Doo::logger()->notice('message...');
Doo::logger()->info('message...');
Doo::logger()->trace('message...');

All of the log messages can be organized by category, simply pass in another parameter at the end of the methods:

Doo::logger()->log('Something fishy here!', DooLog::ALERT, 'editpost');
Doo::logger()->emerg('message...', 'editpost');
Doo::logger()->alert('message...', 'editpost');

To view the logged messages, you just have to call showLogs(). By default DooLog will return a neatly formatted XML log which can be filtered by level or category. You can get a plain text log if you need so:

//display all logs
echo Doo::logger()->showLogs();

//display plain text log
echo Doo::logger()->showLogs(false);

//display only logs in category editpost
echo Doo::logger()->showLogs(true, null, 'editpost');

//display only logs in level Alert and category editpost
echo Doo::logger()->showLogs(true, DooLog::ALERT, 'editpost');

When you have to write the log messages into file, all you have to do is call writeLogs(). Similar to showLogs(), it writes the XML string to file by default.

//Creates a log file

Well lets begin, we start with calling class:

$flash = new DooFlashMessenger();

Now we must give access to DooFlashMessenger from view, we do that like this:

DooController::view()->flashMessenger = $flash;

When we can access from view to flashMessenger we can display messages from flashMessenger, we do that with displayMesssages() method.
Here is the code you need to have in your template file:

$flash->displayMessages();

Thats about it, now you just need to add some message to flash messenger, message will be stored in session, with next execution of DooFlashMessenger class messages that are stored in session will be printed with displayMessages() method. Calling displayMessages() method will echo all messages that are stored.

Adding messages to flashMessenger is done by calling method addMessage:

$flash->addMessage("This is just test message");

That’s it if you have any questions please do ask.

en.svn

test;"This is just a test!"

Lets initialize DooTranslator class:

$translator = Doo::translator('Csv', $this->_basePath . 'languages/en/LC_MESSAGES/en.csv');
 echo $translator->translate("test");

As you can see its very simple, first argument is file type for translation and second is path to the file, third argument can be options array. For Csv you can set options like: delimiter, enclosure and length. Default value for delimiter is “;” and for enclosure is “.

Now we will add some options to our call, lets say we want some other delimiter then “;” and we want to add some caching.

$translator = Doo::translator('Csv', $this->_basePath . 'languages/en/LC_MESSAGES/main.csv', array('cache' => 'apc', 'delimiter' => '|'));

So now we have added cache mechanism that is “apc” and we added delimiter that is “|”, now in our en.csv we must change delimiter:

test|"This is just a test!"

Supported cache mechanisms are “apc”, “php”, “xcache” and “eaccelerator”.

Now lets add placeholders for translate method:

$translator->translate("Hello [_1], wellcome to my website!", array("John"));

This will show translated string with: “Hello John, wellcome to my website!”.

Ok thats about it, if you have any questions please do ask, this is simple translation class its still

These classes have been developed to allow your application(s) to be independent of the database your users choose to use by allowing standard database definition to be used to define your database which is then translated into the SQL needed for the database engine the user is using. It also supports easy upgrading (and downgrading) of the database to allow for better version control support and rolling out of updates and unit testing.

In order to follow this tutorial you will need to use the latest version of DooPHP avaliable form the SVN repository (or version 1.3 or above – not out at the time of writing). The current implementation only supports MySQL and PgSQL at the moment so you will also need one of these 2 databases in order to follow the guide.

The first thing we need to do is to create a simple controller to run our tests from. Therefore create a new controller in your protected/controller/ folder. In this example I will use the controller “DatabaseController”. Now enter the following into the controller:

<?php
class DatabaseController extends DooController {

	public function updateDatabase() {

		echo '<h1>Update Database to Head</h1>' . PHP_EOL;

		/* DB Updater

www/
    superapp/
        proctected/
            index.php
            global/

To move it outside the WWW folder:

     superapp/
        proctected/

    www/
        superapp/
            index.php
            global/

Just change the configs after you move your files, SITE_PATH setting

//original
C:/wamp/www/superapp/

//changes
C:/wamp/superapp/

If you don’t wish to keep the name protected and wanted everything under superapp, try this:

    superapp/
        view/
        controller/
        .....
    www/
        superapp/
            index.php
            global/

Add on a new setting to common.conf.php, PROTECTED_FOLDER:

$config['PROTECTED_FOLDER'] = '';

$mail = new DooMailer();

You can add charset in constructor of DooMailer, default is utf-8.
Everything is pretty easy here is the code:

$mail = new DooMailer();
 $mail->addTo('yyyyy@yyyyy.yyy');
 $mail->addTo('xxxx@xxxx.xxx', 'John Smith');
 $mail->setSubject("This is test subject!");
 $mail->setBodyText("This is plain text body");
 $mail->setBodyHtml("<b>This is HTML body!</b>");
$mail->addAttachment('/var/web/files/file1.jpg');
 $mail->addAttachment('/var/web/files/file2.zip');
 $mail->setFrom('doo@xxxxxxxx.xxx', 'DooPHP ');
 $mail->send();

*** Added new option in setSubject function for forcing encoding of subject:

$mail->setSubject('subject of mail', true);

So as you can see everything is pretty easy, you add to add html body or text body and you can add attachments, when you are adding attachment you just provide link to the file on your website.
And then just do send() it returns true if mail is sent and false if not.

<?php

class CoreController extends DooController {

 /**
 * Current URL
 */

 protected static $_currentUrl = null;

 /**
 * Instance of Doo::db
 */

 protected $_db = null;

 /**
 * Translator
 */
 protected $_translate = null;

 /**
 * Instance of Doo::cache
 */

 protected $_cache = null;

 /**
 * Base path of application
 */

 public $_basePath = null;

 /**
 * Instace of DooSession
 */
 public $_session = null;

 /**
 * Instance of DooAcl
 */

 public $_acl = null;

 /**
 * Host
 */

 public $host = null;

 /**
 * Js path
 */

 public  $jsPath = null;

 public function __construct() {
 $this->_basePath = Doo::conf()->ROOT_DIR;
 // add some globals that we need
 $this->_db = Doo::db();
 $this->_view = DooController::view();
 $this->host = Doo::conf()->host;
 $this->_view->host = Doo::conf()->host;
 // ACL
 $this->_acl = Doo::acl();
 // add sessions
 $this->_session = Doo::session("mywebsite");
 $templateVariables = $this->getSettings();
 // session
 $this->_view->_session = $this->_session;
 $this->_cache = Doo::cache('apc');
 $this->jsPath = $this->_view->host . 'static/js/';
 }

 /**
 * Before run method
 */

 public

Doo::loadHelper('DooForm');

First you create form from array and then just call

echo $form->render();

To render the form, render function is returning html of the form. So we will begin making one simple element, lets say textfield:

$form = new DooForm(array(
    'method' => 'post',
    'action' => $action,
    'elements' => array(
        'username' => array('text', array(
            'required' => true,
            'label' => 'My username: ',
            'attributes' => array("style" => 'border:1px solid #000;', 'class' => 'username-field'),
            'field-wrapper' => 'div',
            'validators' => array(
                array('username',4,7),
                array('maxlength',6,'This is too long'),
                array('minlength',6)
             )
        ))
    )
));

As you can see all form data you can add into form array, so when you are creating form you will have to define method, action and elements you have in your form, elemnts is another array, that array will contain all form elements. You begin with naming your element and then create array that will describe that element (type, label, validators, field-wrappers, etc…)

So in element you will have for example:

'username' => array('text', array(
    'required' => true,
    'label' => 'My username: ',
    'attributes' => array("style" => 'border:1px solid #000;', 'class' => 'mitar'),
    'field-wrapper' => 'div',
    'validators' => array(
        array('username',4,7),
        array('maxlength',6,'This is too long'),
        array('minlength',6))
    )
),

So