Download My Validation Class From http://github.com/harake

This is a very basic class that allows you to add more public static functions to validate more data types other than integer, boolean, decimal, and ids

How To Use It

Currently we have 4 public static methods

1. MyValidation::ValidateBoolean();
2. MyValidation::ValidateInteger();
3. MyValidation::ValidateDecimal();
4. MyValidation::ValidateIds();

Every method returns an array of values or empty array on failure.

Every method can accept any of these sets of consecutive arguments

1. first set
   1. $value_or_array_of_values
2. second set
   1. $value_or_array_of_values
   2. $array_of_possible_values
3. third set
   1. $value_or_array_of_values
   2. $array_of_possible_values
   3. $skip_invalid_values
4. fourth set
   1. $value_or_array_of_values
   2. $array_of_possible_values
   3. $skip_invalid_values
   4. $min_acceptable_number_of_values
5. fifth set
   1. $value_or_array_of_values
   2. $array_of_possible_values
   3. $skip_invalid_values
   4. $min_acceptable_number_of_values
   5. $max_acceptable_number_of_values

Examples

// To validate if the value 3 is an integer

MyValidation::ValidateInteger(3)
MyValidation::ValidateInteger(array(3))

MyValidation::ValidateInteger(3, array(3, 4))
MyValidation::ValidateInteger(array(3), array(3, 4))

MyValidation::ValidateInteger(array(3, 4, 5), array(3, 4, 5, 6))

MyValidation::ValidateInteger(array(3, 4, 5, 'k'), null, true);

MyValidation::ValidateInteger(array(3, 4, 5, 'k'), array(3, 4, 5, 6), true)

MyValidation::ValidateInteger(array(3, 4, 5, 6, 'k'), null, true, 2)

MyValidation::ValidateInteger(array(3, 4, 5, 6, 'k'), null, false, 2)

MyValidation::ValidateInteger(array(3, 4, 5, 6, 'k'), null, true, null, 3)

Please leave a comment, If you like this article or have one or more remark(s) on it

Download The Resize Helper From http://github.com/harake

Copy it to your ‘app\views\helpers’ folder and rename it as resize.php

The Resize Helper requirements

The $helpers array member variable of your controller or your AppController, should look like this

var $helpers = array (..., ..., ..., 'Resize');

The class tries to construct its two public member variables $versions_store and $versions_public where $versions_store is the directory path of the current original image (usually outside the webroot) and $versions_public is the directory path of the current resized image (usually inside the webroot)

How does the class construct them?

Priority of detection

1. Either you set them explicitly in the view because they are public
   • 1.2 style or before, should be an absolute path, the trailing DS is optional
     • $resize->versions_store = APP . ‘uploads’ . DS;
     • $resize->versions_store = APP . ‘uploads’;
   • 1.2 style or before, the webroot itself (default)
     • $resize->versions_public = ”;
   • 1.2 style or before, relative path to the webroot, the trailing DS is optional
     • $resize->versions_public = ‘files’ . DS . ‘versions’ . DS;
     • $resize->versions_public = ‘files’ . DS . ‘versions’;
   • 1.2 style or before, absolute path, the trailing DS is optional
     • $resize->versions_public = WWW_ROOT . ‘files’ . DS . ‘versions’ . DS;
     • $resize->versions_public = WWW_ROOT . ‘files’ . DS . ‘versions’;
   • 1.3 style or higher
     • $this->Resize->versions_public = …;
     • $this->Resize->versions_store = …;
2. Either in your configuration file (‘app\config\bootstrap.php’)
   • Configure::write(‘versions_store’, …);
   • Configure::write(‘versions_public’, …);
3. Or by defining two constants in your configuration file(‘app\config\bootstrap.php’)
   • define(‘VERSIONS_STORE’, …);
   • define(‘VERSIONS_PUBLIC’, …);

The Features In The Resize Helper

When resizing every original image to a smaller one, we have to choose one of the three options

1. wrap (fixed-ratio option)
   • $resize->wrap($filename, $destination_width, $destination_height);
2. pad (complete the smaller destination box with empty pixels)
   • $resize->pad($filename, $destination_width, $destination_height, $x = 2, $y = 2);
3. crop (rarely used, it crop-centered the smaller image)
   • $resize->crop($filename, $destination_width, $destination_height);

Remember that

1. $filename is the relative path to the $versions_store cited above, example ‘image1.jpg’, ‘folder1′ . DS . ‘image1.jpg’, ‘folder1′ . DS . ‘folder2′ . DS . ‘image1.jpg’, etc…
2. $destination_width and $destination_height are strictly positive integer

Please leave a comment, If you like this article or have one or more remark(s) on it

Now you can download the new source code that allows you to add the feature (option) multiple: true when you initialize your accordion instrument.

Download The jQuery UI Accordion Widget From http://github.com/Harake

Please leave a comment, If you like this article or have one or more remark(s) on it

string base64_encode ( string data )
base64_encode() returns data encoded with base64.
This encoding is designed to make binary data survive transport through transport layers that are not 8-bit clean, such as mail bodies.
Base64-encoded data takes about 33% more space than the original data.

Example 1. base64_encode() example

<?php
$str = 'This is an encoded string';
echo base64_encode($str);
?>  

This example will produce:

VGhpcyBpcyBhbiBlbmNvZGVkIHN0cmluZw==

Do we really need the base64?

As far as I know, data at any rate should not be converted in database because conversion:

1. consumes more memory resources (HDD and / OR RAM)
2. consumes more processing resources (CPU and usually this affects performance)…

In fact, sometimes we need the base64 not for storage but for data transportation
example, some non-alpha-numeric characters can not be transported easily via URL.
Cconverting by encoding any string to base-64 leads to another string where each character is one of this set
{

• A to Z (26 characters)
• a to z (26 characters)
• 0 to 9 (10 characters)
• + (the plus operator character)
• / (the famous URL slash character)

}
so there are 64 possible characters.

But there is also the = (the equal operator character) which is used for padding when the original string is not a multiple of three characters.
we are not here to discuss the concept whether it is right or not, but as everyone of us knows, the three characters

• “+”
• “/”
• “=”

have special meanings in URL,  so it is better to convert them to some safe non-alpha-numeric characters

One of the successfull solution I have tested is converting the

• + to – (the dash or the minus operator character)
• / to _ (the underscore)
• = to * (the star or the multiply by operator character)

The code

So In each application that needs to safely transfer some variables via URL, two functions are required

function safe_base64_encode($value) {
 if (!is_string($value)) {
 return false;
 }
 return str_replace(array('+', '/', '='), array('-', '_', '*'), base64_encode($value));
}
 

which returns the safe encoded base-64 string or false when the argument was not string

and

function isBase64($value, $safe = false) {
 if (!is_string($value)) {
 return false;
 }
 if (!$safe) {
 $regexp = '/^([A-Za-z0-9\+\/]{4})*([A-Za-z0-9\+\/]{2}(=|[A-Za-z0-9\+\/])=)?$/';
 } else {
 $regexp = '/^([A-Za-z0-9\-_]{4})*([A-Za-z0-9\-_]{2}(\*|[A-Za-z0-9\-_])\*)?$/';
 }
 if (preg_match($regexp, $value) != 1) {
 return false;
 }
 if ($safe) {
 $value = str_replace(array('-', '_' ,'*'), array('+', '/' ,'='), $value);
 }
 return base64_decode($value);
}

which is used to check if the first argument is base64-encoded where the second argument is to force the safe option, it returns false on error or the original string (base64-decoded)

Please leave a comment, If you like this article or have one or more remark(s) on it

Singleton: one class that (via itself) creates one and only one instance (of itself) if that instance was not created before, and always returns that instance.

ConnectionManager: Class that acts as a a set of singletons, so it creates for each database account one and only one singleton.

The default database account in CakePHP is ‘default’ and it is is of type mysql.

Since most of PHP developers are fans of MySQL (both the mysql and mysqli extensions), I created the class below, to show you how to integrate your old Mysql Connection Manager into the CakePHP framework.

Mysql Connection Manager Class

Downloaded the Mysql Connection Manager From http://github.com/Harake

(I personally put the class in “app\libs\mysql” folder and name it as “mysql_connection_manager.php”)

The Changes in your own “app\config\bootstrap.php”

Just add this function

function cn($account = 'default') {
  if (!class_exists('MysqlConnectionManager')) {
    include_once APP . 'libs' . DS . 'mysql' . DS . 'mysql_connection_manager.php';
  }
  return MysqlConnectionManager::connect($account);
}

Where and how to use it

In general, it can be used anywhere in your application like this

/*

when you call $c = cn();

you are sure that a MySQL connection is created

if it was not existing (singleton pattern)

*/

$c = cn();
if ($c) {
 //...
 $id = $c->loadValue("SELECT MAX(id) FROM users WHERE status = 1");
 $ids = $c->loadColumn("SELECT id FROM users WHERE status = 1");
 $user = $c->loadSingle("SELECT * FROM users WHERE status = 1 LIMIT 1");
 $users = $c->load("SELECT * FROM users WHERE status = 1");
 //... and many more...just read the class to discover
}

Please leave a comment, If you like this article or have one or more remark(s) on it

The FileEngine is currently the default cache engine in CakePHP.

In this article I will change the behavior of the FileEngine caching class by sub-classing it to make it able to do the following:

1. Creates/reads a cached PHP file (real PHP file) that stores one more variable(s).
2. Although IncludeEngine is used for temporary caching (by default), however, adding the key ‘forever’ => true in its configuration will make this cached version “permanent” so the date-time checking is skipped
3. The ‘serialize’ key of the configuration is still true by default, and is still recommend (more secure and even faster!) for any non-resource data type variable (int, float, string, boolean, array, object). However, you may ask the IncludeEngine to create a human readable (in our case non serialized) cached version of the variables you want to store (cache). So setting the ‘serialize’ key of the configuration to false is secure for just scalar variables and scalar arrays (int, float string, boolean and arrays that are based on primitive scalar data type

Include Engine Class

Downloaded the Include Engine From http://github.com/Harake

(I personally put the class in the “app\libs\cache” directory, and I name it as “include.php”)

Changes in your own “app\config\bootstrap.php”

You can create more than one configuration for the include engine, but assume that you want only two, you should do something like this

if (floatval(Configure::read('Cake.version')) < 1.3) {
 include_once APP . 'libs' . DS . 'cache' . DS . 'include.php';
} else {
 include_once APPLIBS . 'cache' . DS . 'include.php';
}
Cache::config('cfg1', array(
 'engine' => 'Include',
 'path' => CACHE . 'persistent' . DS,
 'prefix' => 'CFG1_',
 'serialize' => true
));
Cache::config('cfg2', array(
 'engine' => 'Include',
 'path' => CACHE . 'persistent' . DS,
 'prefix' => 'CFG2_',
 'forever' => true,
 'serialize' => true
));
Cache::config('default');

Where and how to use it

In general, it can be used anywhere in your application like this

Cache::config('cfg1'); // Comment it for 1.3 or higher
$cached_vars = Cache::read('put here the filename', 'cfg1');
if (empty($cached_vars)) {
 //collect the variables with their values before caching them
 Cache::write('put here the filename', array('var1_name' => 'var1_value', 'var2_name' => 'var2_value'), 'cfg1');
 Cache::config('default'); // Comment it for 1.3 or higher
} else {
 Cache::config('default'); // Comment it for 1.3 or higher
 //variables are already cached, let us retrieve them
 $var1_name = $cached_vars['var1_name'];
 $var2_name = $cached_vars['var2_name'];
}

Please leave a comment, If you like this article or have one or more remark(s) on it