<?php
Class Image extends AppModel
{
        var $name = ‘Image’;
        var $validate = array
        (
                ‘uploaded_image’ => array
                (
                        // Ensure file uploaded OK.
                        ‘valid_upload’ => array
                        (
                                ‘rule’ => array(‘validateUploadedfile’, false),
                                ‘message’ => ‘An error occured whilst uploading your image, please try again’,
                        ),
                       
                        // Check image is valid / of allowed mime-type
                        ‘valid_image’ => array
                        (
                                ‘rule’ => array(‘isValidImageFile’),
                                ‘message’ => ‘The file you have uploaded is not a valid or is unsupported, please try again’,
                        ),
                ),
        );

        /**
         * Custom validation rule for uploaded files.
         *
         *  @param Array $data CakePHP File info.
         *  @param Boolean $required Is this field required?
         *  @return Boolean
        */
        function validateUploadedFile($data, $required = false)
        {
                // Remove first level of Array ($data['Image']['size'] becomes $data['size'])
                $upload_info = array_shift($data);

                // No file uploaded.
                if ($required && $upload_info[’size’] == 0) {
                        return false;
                }

                // Check for Basic PHP file errors.
                if ($upload_info[‘error’] !== 0) {
                        return false;
                }

                // Finally, use PHP’s own file validation method.
                return is_uploaded_file($upload_info[‘tmp_name’]);
        }

    /**
     * Use LibGD to determine if an uploaded file is a valid Image by
     * running it’s mime-type against a list of $valid_mime_types
     *
     *  @param Array $data CakePHP File info
     *  @return Boolean
    */
        function isValidImageFile($data)
    {
        // Allow these image mime-types, all others will be rejected
        $valid_mime_types = array(‘image/jpeg’, ‘image/png’, ‘image/gif’);
       
        $data = array_shift($data);
        $filename = $data[‘tmp_name’];
       
        // Catch I/O Errors.
        if (!is_readable($filename)) {
                debug(__METHOD__." failed to read input file: {$filename}");
                return false;
        }
       
        // Retrieve the MimeType of Image, if none is returned, it’s invalid
        if (!$mime_type = $this->getImageMimeType($filename)) {
                debug(__METHOD__." Uploaded file does not have a mime-type");
                return false;
        }
       
        // Check the MimeType against the array of valid ones specified above
        if (!in_array($mime_type, $valid_mime_types)) {
                debug(__METHOD__." Uploaded image has rejected Mime Type: {$mime_type}");
                return false;
        }
       
        if (!$this->__getImageHandleFromFile($filename)) {
                return false;
        }
       
        return true;
    }
   
   
    /**
     * Use LibGD to return an uploaded Image’s MimeType as a String, FALSE
     * on errors or if the file is not an image
     *
     *  @param String $filename Absolute path to file on disc
     *  @return String Image MimeType of $filename, false on failure
    */
    function getImageMimeType($filename)
    {
                // If this error is thrown LibGD is not installed on your server.
        if (!function_exists(‘getimagesize’)) {
                debug(__METHOD__." LibGD PHP Extension was not found, please refer to http://www.php.net/manual/en/book.image.php");
                exit();
        }               
       
        $result = getimagesize($filename);             
        if (isset($result[‘mime’])) {
                return $result[‘mime’];
        }
        return false;
    }
   
   
    /**
     * Returns a LibGD Image Handle for a file specified by $filename
     *
     *  @param String $filename Absolute path to image on disk
     *  @return LibGD Image Handle on success, FALSE on failure.
    */
    function __getImageHandleFromFile($filename)
    {
        if (!is_readable($filename)) {
                debug(__METHOD__." failed to read input file: {$filename}");
                return false;
        }
       
        // Retrieve the MimeType of Image, if none is returned, it’s invalid
        if (!$mime_type = $this->getImageMimeType($filename)) {
                debug(__METHOD__." failed to assertain MimeType of {$filename}");
                return false;
        }
       
        switch ($mime_type)
        {
                case ‘image/jpeg’:
                        $handle = @imagecreatefromjpeg($filename);
                        break;
                       
                case ‘image/gif’:
                        $handle = @imagecreatefromgif($filename);
                        break;
                       
                case ‘image/png’:
                        $handle = @imagecreatefrompng($filename);
                        break;
                       
                default:
                        debug(__METHOD__." Didn’t know how to handle MimeType: {$mime_type}");
                        $handle = false;
                        break;
        }
       
        return $handle;
    }
}
 

– Table structure for table `users`
CREATE TABLE IF NOT EXISTS `users` (
  `id` INT(11) NOT NULL AUTO_INCREMENT,
  `username` VARCHAR(20) NOT NULL,
  `password` VARCHAR(50) NOT NULL,
  `email` VARCHAR(255) NOT NULL,
  `active` TINYINT(1) NOT NULL DEFAULT ‘0′,
  `created` DATETIME NOT NULL,
  `modified` DATETIME NOT NULL,
  PRIMARY KEY  (`id`)
) ENGINE=INNODB  DEFAULT CHARSET=latin1;
 

<?php
// Note: not all logic is show!
uses(’sanitize’);
class UsersController extends AppController
{
        var $name = ‘Users’;
        var $components = array(‘Auth’);
        function login() {
                // Check for incoming login request.
                if ($this->data) {
                        // Use the AuthComponent’s login action
                        if ($this->Auth->login($this->data)) {
                                // Retrieve user data
                                $results = $this->User->find(array(‘User.username’ => $this->data[‘User’][‘username’]), array(‘User.active’), null, false);
                                // Check to see if the User’s account isn’t active
                                if ($results[‘User’][‘active’] == 0) {
                                        // Uh Oh!
                                        $this->Session->setFlash(‘Your account has not been activated yet!’);
                                        $this->Auth->logout();
                                        $this->redirect(‘/users/login’);
                                }
                                // Cool, user is active, redirect post login
                                else {
                                        $this->redirect(‘/’);
                                }
                        }
                }
        }
}
?>

<?php
# /app/models/user.php
# please note that validation logic is not shown
Class User extends AppModel
{
        var $name = ‘User’;

        /**
         * Creates an activation hash for the current user.
         *
         *      @param Void
         *      @return String activation hash.
        */
        function getActivationHash()
        {
                if (!isset($this->id)) {
                        return false;
                }
                return substr(Security::hash(Configure::read(‘Security.salt’) . $this->field(‘created’) . date(‘Ymd’)), 0, 8);
        }
}
?>

<?php
# /controllers/users_controller.php
# please note that not all code is shown…
uses(’sanitize’);
class UsersController extends AppController {
        var $name = ‘Users’;
        // Include the Email Component so we can send some out :)
        var $components = array(‘Email’, ‘Auth’);
       
        // Allow users to access the following action when not logged in       
        function beforeFilter() {
                $this->Auth->allow(‘register’, ‘thanks’, ‘confirm’, ‘logout’);
                $this->Auth->autoRedirect = false;
        }
       
        // Allows a user to sign up for a new account
        function register() {
                if (!empty($this->data)) {
                        // See my previous post if this is forgien to you
                        $this->data[‘User’][‘password’] = $this->Auth->password($this->data[‘User’][‘passwrd’]);
                        $this->User->data = Sanitize::clean($this->data);
                        // Successfully created account – send activation email                
                        if ($this->User->save()) {
                                $this->__sendActivationEmail($this->User->getLastInsertID());

                                // this view is not show / listed – use your imagination and inform
                                // users that an activation email has been sent out to them.
                                $this->redirect(‘/users/thanks’);
                        }
                        // Failed, clear password field
                        else {
                                $this->data[‘User’][‘passwrd’] = null;
                        }
                }
        }

        /**
         * Send out an activation email to the user.id specified by $user_id
         *  @param Int $user_id User to send activation email to
         *  @return Boolean indicates success
        */
        function __sendActivationEmail($user_id) {
                $user = $this->User->find(array(‘User.id’ => $user_id), array(‘User.email’, ‘User.username’), null, false);
                if ($user === false) {
                        debug(__METHOD__." failed to retrieve User data for user.id: {$user_id}");
                        return false;
                }

                // Set data for the "view" of the Email
                $this->set(‘activate_url’, ‘http://’ . env(‘SERVER_NAME’) . ‘/users/activate/’ . $user[‘User’][‘id’] . ‘/’ . $this->User->getActivationHash());
                $this->set(‘username’, $this->data[‘User’][‘username’]);
               
                $this->Email->to = $user[‘User’][‘email’];
                $this->Email->subject = env(‘SERVER_NAME’) . ‘ – Please confirm your email address’;
                $this->Email->from = ‘noreply@’ . env(‘SERVER_NAME’);
                $this->Email->template = ‘user_confirm’;
                $this->Email->sendAs = ‘text’;   // you probably want to use both :)   
                return $this->Email->send();
        }
}
?>

<?php
# /app/views/elements/email/text/user_confirm.ctp
?>
Hey there <?= $username ?>, we will have you up and running in no time, but first we just need you to confirm your user account by clicking the link below:

<?= $activate_url ?>

 

<?php
# /controllers/user_controller.php
# note that only the activate function is shown…

/**
 * Activates a user account from an incoming link
 *
 *  @param Int $user_id User.id to activate
 *  @param String $in_hash Incoming Activation Hash from the email
*/
function activate($user_id = null, $in_hash = null) {
        $this->User->id = $id;
        if ($this->User->exists() && ($in_hash == $this->User->getActivationHash()))
        {
                // Update the active flag in the database
                $this->User->saveField(‘active’, 1);
               
                // Let the user know they can now log in!
                $this->Session->setFlash(‘Your account has been activated, please log in below’);
                $this->redirect(‘login’);
        }
       
        // Activation failed, render ‘/views/user/activate.ctp’ which should tell the user.
}
?>

ini_set(‘include_path’, CAKE_CORE_INCLUDE_PATH . PATH_SEPARATOR . ROOT . DS . APP_DIR . DS . PATH_SEPARATOR . ini_get(‘include_path’));
 

ini_set(‘include_path’, CAKE_CORE_INCLUDE_PATH . PATH_SEPARATOR . ROOT . DS . APP_DIR . DS);
 

<?php
# /app/views/story/create.ctp
echo $form->create(‘Story’, array(‘action’ => ‘create’, ‘type’ => ‘file’));
echo $form->input(‘Story.title’);
echo $form->input(‘Story.contents’);
echo $form->input(‘Artwork.uploaded_image’, array(‘type’ => ‘file’, ‘label’ => ‘Front Artwork’));
echo $form->end(‘Create Story’);
?>