/**
* Check if resource is empty
*
* @param resource $resource The resource
*
* @return bool
*/
public static function isEmpty($resource)
{
if (!self::isValid($resource) && null !== $resource) {
return false;
}
return String::isEmpty($resource);
}
public static function parameterValidation($file)
{
if (!(String::isEmpty($file, $trim = TRUE) === FALSE)) {
return -1;
}
return getimagesize(new File($file)) ? TRUE : -2;
}
/**
* Initializes a new File Object from parent and child or just parent.
*/
public function __construct($parent = "", $child = "") {
$parent = new String($parent);
$child = new String($child);
if($parent->isEmpty())
throw new Exception("File path cannot be empty.");
if($parent->isEmpty() && $child->isEmpty())
throw new Exception("File path cannot be empty.");
if($parent->substring(-1) == $this::seperatorChar && !$child->isEmpty())
$this->path = $parent . $child;
else if(!$child->isEmpty())
$this->path = $parent . $this::seperatorChar . $child;
else
$this->path = $parent;
}
/**
* Private method which normalizes email argument validation throughout all of the
* contained methods of this class.
* @param String $email
* @return Int -1 Given argument is not a string
* @return Int -2 Given argument is empty
* @return boolean TRUE argument is a valid email
* @return boolean FALSE $email argument is an invalid email
*/
public static function parameterValidation($email)
{
if (!String::isString($email)) {
return -1;
}
if (String::isEmpty($email, $useTrim = TRUE)) {
return -2;
}
$addressDomain = substr($email, strpos($email, '@') + 1);
$mxRecords = array();
if (!getmxrr($addressDomain, $mxRecords)) {
return -3;
}
return filter_var($email, FILTER_VALIDATE_EMAIL) === FALSE ? -4 : TRUE;
}
/**
*Checks if a class has a method named $method (boolean mode)
*
*@param String $name class name
*@param String $method method to be checked
*@param Mixed $filters, a set of filters to check for class attributes such as public,
* private, abstract, final, etc. You can specify a string such as "abstract"
* or you can specify a set of filters in an Array like structure
* for instance, specifying $filters to Array('static','public')
* would check for a method named $method that is both static AND public.
* Note: This is affected according to the mode you specify,
* which is by default "all", meaning that every filter you specify
* must be present in the given method.
*
*@param String $mode mode can be any of "all", "any" or "some". The default mode is "all"
*
* "all" mode: the method must contain ALL and *ONLY* the parameters that you
* specify in the $filters argument. If it contains extra attributes it will be
* considered as invalid.
*
* "any" mode: the method must contain at least ONE of the parameters specified
* in $filters. Extra attributes don't matter.
*
* "some" mode: the method must contain all of the attributes specified in
* $filters, but if it contains any other attribute it's still considered
* valid.
*
* is necessary to exist in the given method for it to be TRUE.
*
*
*@param String $msg Exception message if any
*@param Int $exCode Exception code
*
*@return Int -6 if $filters are not null and an empty string was entered
*@return Int -7 if $filters are an array but the array elements are not strings or it's empty
*@return Int -8 ONLY if specified filters are empty
*@return Int -9 ONLY if an invalid filter was specified
*@return Int -10 Method doesn't exists
*@return boolean TRUE if the class has a method named $method
*@return boolean FALSE if the class doesn't has a method named $method
*
*@see self::parameterValidation for other return values
*/
public static function hasMethod($name, $method, $filters = NULL, $mode = "all")
{
$validModes = array('all', 'any', 'some');
$stdValidation = self::parameterValidation($name, $method);
//something went wrong
if (!($stdValidation === TRUE)) {
return $stdValidation;
}
$rc = new \ReflectionClass($name);
//If no filters where specified, then check if the given class has a given method
//and thats it! We don't need further checking if the user hasn't specified any filters.
if (is_null($filters)) {
return $rc->hasMethod($method);
}
//Check if specified $filters are invalid
if (is_string($filters)) {
if (String::isEmpty($filters)) {
return -6;
}
}
//If it's an array but the array is not made of strings
if (!is_null(Vector::isArray($filters)) && !Vector::isMadeOfStrings($filters)) {
return -7;
}
if (is_string($filters)) {
$filters = array($filters);
}
$mode = strtolower($mode);
//Specified $mode is invalid (not one of all,any or some)
if (String::isEmpty($mode) || !in_array($mode, $validModes)) {
return -7;
}
//Check if entered filters are not empty
if (empty($filters)) {
return -8;
}
//Check if entered filters are valid
foreach ($filters as $filter) {
$filter = sprintf('IS_%s', strtoupper($filter));
//If an invalid filter is detected, then return -9
if (!self::hasConstant('\\ReflectionMethod', $filter)) {
return -9;
}
}
//Fetch all class methods
$methods = $rc->getMethods();
$found = FALSE;
foreach ($methods as $m) {
//If the current method is not equal to the selected one then continue
//with the next element in the array
if ($m->name !== $method) {
continue;
}
$found = TRUE;
break;
}
//Method not found
if (!$found) {
return -8;
}
//Get all method modifiers (public, abstract, private, final, etc)
$modifiers = \Reflection::getModifierNames($m->getModifiers());
switch ($mode) {
case "any":
foreach ($filters as $f) {
if (in_array($f, $modifiers)) {
return TRUE;
}
}
return FALSE;
break;
case "some":
$count = 0;
foreach ($modifiers as $mod) {
if (in_array($mod, $filters)) {
$count++;
}
}
return $count == sizeof($filters);
break;
case "all":
foreach ($modifiers as $mod) {
if (!in_array($mod, $filters)) {
return FALSE;
}
}
return TRUE;
break;
}
}
/**
* Convert a string to an array
*
* @param string $string The string
* @param string $delimiter The delimiter
*
* @return array
*/
public static function explode($string, $delimiter)
{
if (!String::isValid($string) || String::isEmpty($string)) {
return false;
}
return explode($delimiter, $string);
}
/**
* Validates that an array like structure is made of strings
* @param Mixed $array
* @param boolean $nonEmpty whether or not the strings contained inside the array can be empty
* @return boolean TRUE
* @return Mixed Index position where the failure condition has been found.
*/
public static function isMadeOfStrings($array, $nonEmpty = TRUE)
{
$stdValidation = self::parameterValidation($array);
if (!($stdValidation === TRUE)) {
return $stdValidation;
}
foreach ($array as $key => $val) {
if (is_object($val)) {
if (!Object::hasMethod($val, "__toString")) {
return $key;
}
//print the object
$val = sprintf('%s', $val);
}
if ($nonEmpty && String::isEmpty($val)) {
return $key;
}
}
return TRUE;
}
/**
* Generate random number
*
* @param int $min Minimum value
* @param int $max Maximum value
*
* @return int
*/
public static function random($min, $max = null)
{
if (String::isEmpty($max) || $max > getrandmax()) {
$max = getrandmax();
}
return rand($min, $max);
}
/**
* Sets the requested Exchange server version
* @param string $version
* @return null
* @throws zibo\ZiboException when the provided version is empty
*/
protected function setVersion($version)
{
if ($version === null) {
$version = self::DEFAULT_VERSION;
} elseif (String::isEmpty($version)) {
throw new ZiboException('Provided version is empty');
}
$this->version = $version;
}
public function testIsEmpty()
{
$o = new String(self::MULTI_LINE);
$this->assertFalse($o->isEmpty());
$o = new String('');
$this->assertTrue($o->isEmpty());
}
$database = new Database(); // initialize class $database->connect(); // connect to db LookbookDatabase::$database = $database; // pass database accessor //email-redirect.php?email=mrjesuserwinsuarez@gmail.com&action=private-beta&redirect=TRUE //email-redirect.php?&email=mrjesuserwinsuarez@gmail.com&action=signup&redirect=TRUE //email-redirect.php?&email=mrjesuserwinsuarez@gmail.com&action=remove&redirect=TRUE //email-redirect.php?&email=mrjesuserwinsuarez@gmail.com&action=open&redirect //email-redirect.php?&email=mrjesuserwinsuarez@gmail.com&action=Recieved Invitation&redirect // $action = 'signup'; // $id = 1; // $email = '*****@*****.**'; //other initialized $defaultLink = 'http://fashionsponge.com/'; $action = String::isEmpty($_GET['action'], ''); $email = String::isEmpty($_GET['email'], ''); $redirect = String::isEmpty($_GET['redirect'], FALSE); $qid = !empty($_GET['qid']) ? $_GET['qid'] : 0; $fname = LookbookDatabase::getFullNameByEmail($email); //notification send to admin when email clicked action $to = Program::$adminEmail; //'mrjesuserwinsuarez@gmail.com,pecotrain1@gmail.com'; $subject = 'invited person clicked the email content ' . $action; $body = 'Email: ' . $email . "\n" . 'First Name: ' . $fname . "\n" . ' Action: ' . $action; $from = $email; $title = 'FS ' . $action; echo "<div style='display:none' >"; Program::emailInvitationClickedSaveActivityAndRedirectLocation($defaultLink, $action, $redirect, $to, $subject, $body, $from, $title, $qid, $email); echo "</div>";
private function scanTemporaryUploadPath(Io_Path $path_, $subPath_ = '')
{
if (false === String::isEmpty($subPath_) && false === String::endsWith($subPath_, '/')) {
$subPath_ .= '/';
}
foreach ($path_ as $entry) {
if ($entry->isDot()) {
continue;
}
if ($entry->isFile()) {
$this->stashFile($entry->asFile(), $subPath_);
} else {
if ($entry->isDirectory()) {
$this->scanTemporaryUploadPath($entry, $subPath_ . $entry->getName());
}
}
}
$path_->delete(true);
}
public function testIsEmpty()
{
$string = new String();
$this->assertTrue($string->isEmpty());
}