PHP Validator::isValidEmail方法代码示例

 /**
 	returns true if the input is valid; an array of errors (key is error name, value is true) if invalid
 */
 private static function registerInputIsValid($username, $password, $retypedPassword, $email, $retypedEmail)
 {
     if ($username == "") {
         $errors['noUsername'] = true;
     }
     if (!Validator::usernameIsValidLength($username)) {
         $errors['longUsername'] = true;
     }
     if ($password == "") {
         $errors['noPassword'] = true;
     }
     if (!Validator::passwordIsValidLength($password)) {
         $errors['longPassword'] = true;
     }
     //password mismatch
     if ($password != $retypedPassword) {
         $errors['passwordMismatch'] = true;
     }
     if ($email == "") {
         $errors['noEmail'] = true;
     }
     if (!Validator::isValidEmail($email)) {
         $errors['invalidEmail'] = true;
     }
     if ($email != $retypedEmail) {
         $errors['emailMismatch'] = true;
     }
     return isset($errors) ? $errors : true;
 }

 /**
  * Validates the form based on the 'validations' attribute in the form array.
  */
 private function validate()
 {
     foreach ($this->settings as $name => $settings) {
         $value = $_POST[$name];
         if (isset($settings['validations'])) {
             foreach ($settings['validations'] as $validation) {
                 switch ($validation) {
                     case 'not_empty':
                         //if (!\ThirdParty\Utilities\Validator::notEmpty($value)) {
                         //if (!OtherValidator::notEmpty($value)) {
                         if (!Validator::notEmpty($value)) {
                             return false;
                         }
                         break;
                     case 'is_valid_email':
                         //if (!\ThirdParty\Utilities\Validator::isValidEmail($value)) {
                         //if (!OtherValidator::isValidEmail($value)) {
                         if (!Validator::isValidEmail($value)) {
                             return false;
                         }
                         break;
                 }
             }
         }
     }
     return true;
 }

 protected function buildQuery($searchString)
 {
     $this->filter = $filter = false;
     $this->errorNo = $this->errorMsg = null;
     $objectClassQuery = new LDAPFilter('objectClass', 'person');
     if (empty($searchString)) {
         $this->errorMsg = "Query was blank";
     } elseif (Validator::isValidEmail($searchString)) {
         $filter = new LDAPFilter($this->getField('email'), $searchString);
     } elseif (Validator::isValidPhone($searchString, $phone_bits)) {
         array_shift($phone_bits);
         $searchString = implode("", $phone_bits);
         // remove any separators. This might be an issue for people with formatted numbers in their directory
         $filter = new LDAPFilter($this->getField('phone'), $searchString);
     } elseif (preg_match('/^[0-9]+/', $searchString)) {
         //partial phone number
         $filter = new LDAPFilter($this->getField('phone'), $searchString, LDAPFilter::FILTER_OPTION_WILDCARD_TRAILING);
     } elseif (preg_match('/[A-Za-z]+/', $searchString)) {
         // assume search by name
         $names = preg_split("/\\s+/", $searchString);
         $nameCount = count($names);
         switch ($nameCount) {
             case 1:
                 //try first name, last name and email
                 $snFilter = new LDAPFilter($this->getField('lastname'), $searchString, LDAPFilter::FILTER_OPTION_WILDCARD_TRAILING);
                 $givenNameFilter = new LDAPFilter($this->getField('firstname'), $searchString, LDAPFilter::FILTER_OPTION_WILDCARD_TRAILING);
                 $mailFilter = new LDAPFilter($this->getField('email'), $searchString, LDAPFilter::FILTER_OPTION_WILDCARD_TRAILING);
                 $filter = new LDAPCompoundFilter(LDAPCompoundFilter::JOIN_TYPE_OR, $givenNameFilter, $snFilter, $mailFilter);
                 break;
             case 2:
                 $filter1 = $this->nameFilter($names[0], $names[1]);
                 $filter2 = $this->nameFilter($names[1], $names[0]);
                 $filter = new LDAPCompoundFilter(LDAPCompoundFilter::JOIN_TYPE_OR, $filter1, $filter2);
                 break;
             default:
                 $filters = array();
                 // Either the first word is the first name, or it's a title and the
                 // second word is the first name.
                 $possibleFirstNames = array($names[0], $names[1]);
                 // Either the last word is the last name, or the last two words taken
                 // together are the last name.
                 $possibleLastNames = array($names[$nameCount - 1], $names[$nameCount - 2] . " " . $names[$nameCount - 1]);
                 foreach ($possibleFirstNames as $i => $firstName) {
                     foreach ($possibleLastNames as $j => $lastName) {
                         $filters[] = $this->nameFilter($firstName, $lastName);
                     }
                 }
                 // Kitchen sink -- just string them all together with wildcards
                 // and hope that it's a match on the common name.
                 $filters[] = new LDAPFilter('cn', implode("*", array_map(array('LDAPFilter', 'ldapEscape'), $names)), LDAPFilter::FILTER_OPTION_NO_ESCAPE);
                 $filter = new LDAPCompoundFilter(LDAPCompoundFilter::JOIN_TYPE_OR, $filters);
         }
     } else {
         $this->errorMsg = "Invalid query";
     }
     if ($filter) {
         $this->filter = new LDAPCompoundFilter(LDAPCompoundFilter::JOIN_TYPE_AND, $objectClassQuery, $filter);
     }
     return $this->filter;
 }

 public function isValidEmail($string)
 {
     global $db;
     if (!parent::isValidEmail($string)) {
         return false;
     }
     $query = "Select count(user_id) from users inner join companies on users.id = companies.user_id where users.name = '" . $string . "';";
     $h = $db->query($query);
     $value = $db->getOne($h);
     if ($value) {
         return true;
     }
     return false;
 }

//Create Validator Object
$validate = new Validator();
if (isset($_POST['register'])) {
    //Create Data Array
    $data = array();
    $data['name'] = $_POST['name'];
    $data['email'] = $_POST['email'];
    $data['username'] = $_POST['username'];
    $data['password'] = md5($_POST['password']);
    $data['password2'] = md5($_POST['password2']);
    $data['about'] = $_POST['about'];
    $data['last_activity'] = date("Y-m-d H:i:s");
    //Required Fields
    $field_array = array('name', 'email', 'username', 'password', 'password2');
    if ($validate->isRequired($field_array)) {
        if ($validate->isValidEmail($data['email'])) {
            if ($validate->passwordsMatch($data['password'], $data['password2'])) {
                //Upload Avatar Image
                if ($user->uploadAvatar()) {
                    $data['avatar'] = $_FILES["avatar"]["name"];
                } else {
                    $data['avatar'] = 'noimage.png';
                }
                //Register User
                if ($user->register($data)) {
                    redirect('index.php', 'You are registered and can now log in', 'success');
                } else {
                    redirect('index.php', 'Something went wrong with registration', 'error');
                }
            } else {
                redirect('register.php', 'Your passwords did not match', 'error');

 function check()
 {
     $this->errors = array();
     if (empty($this->to)) {
         $this->errors[] = GC_E_FIELD_TO;
     }
     if (empty($this->from)) {
         $this->errors[] = GC_E_FIELD_FROM;
     }
     if (Validator::isValidFloat($this->amount) == false || $this->amount < 0.01) {
         $this->errors[] = GC_E_FIELD_AMOUNT;
     }
     $this->amount = floor($this->amount * 100) / 100;
     if ($this->sendtype != GC_SENDTYPE_EMAIL && $this->sendtype != GC_SENDTYPE_POST) {
         $this->errors[] = GC_E_FIELD_SENDTYPE;
     }
     if ($this->sendtype == GC_SENDTYPE_EMAIL && !Validator::isValidEmail($this->email)) {
         $this->errors[] = GC_E_FIELD_EMAIL;
     }
     if ($this->sendtype == GC_SENDTYPE_POST) {
         if (empty($this->fname)) {
             $this->errors[] = GC_E_FIELD_FNAME;
         }
         if (empty($this->lname)) {
             $this->errors[] = GC_E_FIELD_LNAME;
         }
         if (empty($this->address)) {
             $this->errors[] = GC_E_FIELD_ADDRESS;
         }
         if (empty($this->city)) {
             $this->errors[] = GC_E_FIELD_CITY;
         }
         if (empty($this->zip)) {
             $this->errors[] = GC_E_FIELD_ZIP;
         }
         if (empty($this->country_id)) {
             $this->errors[] = GC_E_FIELD_COUNTRYID;
         }
         if (empty($this->state_id)) {
             $this->errors[] = GC_E_FIELD_STATEID;
         }
     }
     return empty($this->errors);
 }

 /**
  * Sees if the given user matches the rule
  * @param User $user a valid user object
  * @return mixed, the action if the user matches the rule or false if the rule did not match
  */
 public function evaluateForUser(User $user)
 {
     switch ($this->ruleScope) {
         case self::RULE_SCOPE_USER:
             /* if the value is all then see if the userID is set
                   this will NOT match an anonymous user 
                */
             if ($this->ruleAuthority) {
                 if ($user->getAuthenticationAuthorityIndex() == $this->ruleAuthority) {
                     /* can match either userID or email */
                     if ($this->ruleValue == self::RULE_VALUE_ALL) {
                         if ($user->getUserID()) {
                             return $this->ruleAction;
                         }
                     } else {
                         if ($user->getUserID() == $this->ruleValue || Validator::isValidEmail($this->ruleValue) && $user->getEmail() == $this->ruleValue) {
                             return $this->ruleAction;
                         }
                     }
                 }
             } elseif ($this->ruleValue == self::RULE_VALUE_ALL) {
                 if ($user->getUserID()) {
                     return $this->ruleAction;
                 }
             } else {
                 if ($user->getUserID() == $this->ruleValue || Validator::isValidEmail($this->ruleValue) && $user->getEmail() == $this->ruleValue) {
                     return $this->ruleAction;
                 }
             }
             break;
         case self::RULE_SCOPE_GROUP:
             /* Note: a group value of ALL is not valid */
             if ($authority = AuthenticationAuthority::getAuthenticationAuthority($this->ruleAuthority)) {
                 if ($group = $authority->getGroup($this->ruleValue)) {
                     /* see if the user is a member of the group */
                     if ($group->userIsMember($user)) {
                         return $this->ruleAction;
                     }
                 }
             }
             break;
         case self::RULE_SCOPE_EVERYONE:
             /* always matches */
             return $this->ruleAction;
             break;
     }
     return false;
 }

 private function getPasswdUserData($login)
 {
     if (strlen($login)==0) {
         return false;
     }
     
     $this->loadUserData();
     
     if (isset($this->users[$login])) {
         return $this->users[$login];
     }
     
     if (Validator::isValidEmail($login) && (($userID = array_search($login, $this->userEmails)) !== false)) {
         return $this->getPasswdUserData($userID);
     } 
     
     return false;
 }

    public function search($searchString) {
        $sql = "";
        $parameters = array();

        if (empty($searchString)) {
            $this->errorMsg = "Query was blank";
            return;
        } elseif (Validator::isValidEmail($searchString)) {
            $sql = sprintf("SELECT %s FROM %s WHERE %s LIKE '%%?%%'", '*', $this->table, $this->getField('email'));
            $parameters = array($searchString);
        } elseif (Validator::isValidPhone($searchString, $phone_bits)) {
            array_shift($phone_bits);
            $searchString = implode("", $phone_bits); // remove any separators. This might be an issue for people with formatted numbers in their directory
            $sql = sprintf("SELECT %s FROM %s WHERE %s LIKE '%%?%%'", '*', $this->table, $this->getField('phone'));
            $parameters = array($searchString);
        } elseif (preg_match('/[A-Za-z]+/', $searchString)) { // assume search by name

            $names = preg_split("/\s+/", $searchString);
            $nameCount = count($names);
            $where = array();

            switch ($nameCount)
            {
                case 1:
                    //try first name, last name and email
                    $where = sprintf("(%s LIKE ? OR %s LIKE ? OR %s LIKE ?)", $this->getField('firstname'), $this->getField('lastname'), $this->getField('email'));
                    $parameters = array($searchString.'%', $searchString.'%', $searchString.'%');
                    break;
                case 2:
                    $where = sprintf("((%s LIKE ? AND %s LIKE ?) OR (%s LIKE ? AND %s LIKE ?))",
                        $this->getField('firstname'), $this->getField('lastname'),
                        $this->getField('lastname'), $this->getField('firstname')
                    );
                        
                    $parameters = array($names[0].'%', $names[1].'%', $names[0].'%', $names[1].'%');
                    break;                
                    
                default:
                    $filters = array();
                    // Either the first word is the first name, or it's a title and the 
                    // second word is the first name.
                    $possibleFirstNames = array($names[0], $names[1]);
                    
                    // Either the last word is the last name, or the last two words taken
                    // together are the last name.
                    $possibleLastNames = array($names[$nameCount - 1],
                                               $names[$nameCount - 2] . " " . $names[$nameCount - 1]);

                    
                    $parameters = array();
                    foreach ($possibleFirstNames as $i => $firstName) {
                        foreach ($possibleLastNames as $j => $lastName) {
                            $where[] = sprintf("(%s LIKE ? AND %s LIKE ?)", $this->getField('firstname'), $this->getField('lastname'));
                            $parameters[] = $firstName;
                            $parameters[] = $lastName;
                        }
                    }

                    $where = implode(" OR ", $where);
            }

        } else {
            $this->errorMsg = "Invalid query";
            return array();
        }

        $sql = sprintf("SELECT %s FROM %s WHERE %s ORDER BY %s", '*', $this->table, $where, implode(",", array_map(array($this,'getField'),$this->sortFields)));
        
        $results = array();
        if ($result = $this->connection->query($sql, $parameters)) {
            while ($row = $result->fetch()) {
                $person = new $this->personClass();
                $person->setFieldMap($this->fieldMap);
                $person->setAttributes($row);
                $results[] = $person;
            }
        } 
        
        return $results;        
    }

require 'core/init.php';
?>

<?php 
// Create Validator Object
$validate = new Validator();
if (isset($_POST['send_email'])) {
    $admin = "your.email@email.com";
    $subject = $_POST['subject'];
    $email = $_POST['email'];
    $message = $_POST['message'];
    // Required Fields
    $input_array = array('subject', 'email', 'message');
    if ($validate->isRequired($input_array)) {
        if ($validate->isValidEmail($email)) {
            if ($validate->newLineChar($email, $subject)) {
                mail($admin, $subject, $message, 'From: ' . $email);
                redirect('contact.php', 'Your message was succesfully sent!', 'success');
            } else {
                redirect('contact.php', 'Something went wrong with your email.', 'error');
            }
        } else {
            redirect('contact.php', 'Please enter a valid email.', 'error');
        }
    } else {
        redirect('contact.php', 'All input fields are required!', 'error');
    }
}
// Get Template & Assign Vars
$template = new Template('templates/contact.php');

 protected function buildSearchFilter($searchString)
 {
     $filter = $this->errorNo = $this->errorMsg = null;
     $objectClassQuery = new LDAPFilter('objectClass', 'person');
     $searchString = trim($searchString);
     if (empty($searchString)) {
         $this->errorMsg = "Query was blank";
     } elseif (Validator::isValidEmail($searchString)) {
         $filter = new LDAPFilter($this->getField('email'), $searchString);
     } elseif (Validator::isValidPhone($searchString, $phone_bits)) {
         array_shift($phone_bits);
         $searchString = implode("", $phone_bits);
         // remove any separators. This might be an issue for people with formatted numbers in their directory
         $filter = new LDAPFilter($this->getField('phone'), $searchString);
     } elseif (preg_match('/^[0-9]{' . $this->MIN_PHONE_SEARCH . ',}/', $searchString)) {
         //partial phone number
         $filter = new LDAPFilter($this->getField('phone'), $searchString, LDAPFilter::FILTER_OPTION_WILDCARD_SURROUND);
     } elseif (strlen(trim($searchString)) < self::MIN_NAME_SEARCH) {
         $firstFilter = new LDAPFilter($this->getField('firstname'), $searchString);
         $lastFilter = new LDAPFilter($this->getField('lastname'), $searchString);
         $filter = new LDAPCompoundFilter(LDAPCompoundFilter::JOIN_TYPE_OR, $firstFilter, $lastFilter);
     } elseif (preg_match('/[A-Za-z]+/', $searchString)) {
         // assume search by name
         $names = preg_split("/\\s+/", $searchString);
         $nameCount = count($names);
         switch ($nameCount) {
             case 1:
                 //try first name, last name and email
                 // Use surround wildcard if specified in config
                 $filterWildCardOption = $this->useSurroundWildcard ? LDAPFilter::FILTER_OPTION_WILDCARD_SURROUND : LDAPFilter::FILTER_OPTION_WILDCARD_TRAILING;
                 $snFilter = new LDAPFilter($this->getField('lastname'), $searchString, $filterWildCardOption);
                 $givenNameFilter = new LDAPFilter($this->getField('firstname'), $searchString, $filterWildCardOption);
                 $mailFilter = new LDAPFilter($this->getField('email'), $searchString, $filterWildCardOption);
                 $filter = new LDAPCompoundFilter(LDAPCompoundFilter::JOIN_TYPE_OR, $givenNameFilter, $snFilter, $mailFilter);
                 break;
             case 2:
                 $filter1 = $this->nameFilter($names[0], $names[1]);
                 $filter2 = $this->nameFilter($names[1], $names[0]);
                 $filter = new LDAPCompoundFilter(LDAPCompoundFilter::JOIN_TYPE_OR, $filter1, $filter2);
                 break;
             default:
                 $filters = array();
                 // Either the first word is the first name, or it's a title and the
                 // second word is the first name.
                 $possibleFirstNames = array($names[0], $names[1]);
                 // Either the last word is the last name, or the last two words taken
                 // together are the last name.
                 $possibleLastNames = array($names[$nameCount - 1], $names[$nameCount - 2] . " " . $names[$nameCount - 1]);
                 foreach ($possibleFirstNames as $i => $firstName) {
                     foreach ($possibleLastNames as $j => $lastName) {
                         $filters[] = $this->nameFilter($firstName, $lastName);
                     }
                 }
                 // Kitchen sink -- just string them all together with wildcards
                 // and hope that it's a match on the common name.
                 $filters[] = new LDAPFilter('cn', implode("*", array_map(array('LDAPFilter', 'ldapEscape'), $names)), LDAPFilter::FILTER_OPTION_NO_ESCAPE);
                 $filter = new LDAPCompoundFilter(LDAPCompoundFilter::JOIN_TYPE_OR, $filters);
         }
         //build search for additional fields
         if (($searchFields = $this->getSearchFields()) && $filter instanceof LDAPCompoundFilter) {
             foreach ($searchFields as $field) {
                 $fieldFilter = new LDAPFilter($field, $searchString, LDAPFilter::FILTER_OPTION_WILDCARD_SURROUND);
                 $filter->addFilter($fieldFilter);
             }
         }
     } else {
         $this->errorMsg = "Invalid query";
     }
     if ($this->additionalFilters) {
         $filters = array_merge(array($filter), $this->additionalFilters);
         $filter = new LDAPCompoundFilter(LDAPCompoundFilter::JOIN_TYPE_AND, $filters);
     }
     return $filter;
 }

 protected function buildSearchQuery($searchString)
 {
     $sql = "";
     $parameters = array();
     if (empty($searchString)) {
         $this->errorMsg = "Query was blank";
         return;
     } elseif (Validator::isValidEmail($searchString)) {
         $sql = sprintf("SELECT %s FROM %s WHERE %s LIKE ?", '*', $this->table, $this->getField('email'));
         $parameters = array('%' . $searchString . '%');
     } elseif ($this->getField('phone') && Validator::isValidPhone($searchString, $phone_bits)) {
         array_shift($phone_bits);
         $searchString = implode("", $phone_bits);
         // remove any separators. This might be an issue for people with formatted numbers in their directory
         $sql = sprintf("SELECT %s FROM %s WHERE %s LIKE ?", '*', $this->table, $this->getField('phone'));
         $parameters = array($searchString . '%');
     } elseif ($this->getField('phone') && preg_match('/^[0-9]+/', $searchString)) {
         //partial phone number
         $sql = sprintf("SELECT %s FROM %s WHERE %s LIKE ?", '*', $this->table, $this->getField('phone'));
         $parameters = array($searchString . '%');
     } elseif (strlen(trim($searchString)) < self::MIN_NAME_SEARCH) {
         $sql = sprintf("SELECT %s FROM %s WHERE %s = ? OR %s = ?", '*', $this->table, $this->getField('firstname'), $this->getField('lastname'));
         $parameters = array($searchString, $searchString);
     } elseif (preg_match('/[A-Za-z]+/', $searchString)) {
         // assume search by name
         $names = preg_split("/\\s+/", $searchString);
         $nameCount = count($names);
         $where = array();
         switch ($nameCount) {
             case 1:
                 //try first name, last name and email
                 $where = sprintf("(%s LIKE ? OR %s LIKE ? OR %s LIKE ?)", $this->getField('firstname'), $this->getField('lastname'), $this->getField('email'));
                 $parameters = array($searchString . '%', $searchString . '%', '%' . $searchString . '%');
                 break;
             case 2:
                 $where = sprintf("((%s LIKE ? AND %s LIKE ?) OR (%s LIKE ? AND %s LIKE ?))", $this->getField('firstname'), $this->getField('lastname'), $this->getField('lastname'), $this->getField('firstname'));
                 $parameters = array($names[0] . '%', $names[1] . '%', $names[0] . '%', $names[1] . '%');
                 break;
             default:
                 // Either the first word is the first name, or it's a title and the
                 // second word is the first name.
                 $possibleFirstNames = array($names[0], $names[1]);
                 // Either the last word is the last name, or the last two words taken
                 // together are the last name.
                 $possibleLastNames = array($names[$nameCount - 1], $names[$nameCount - 2] . " " . $names[$nameCount - 1]);
                 $parameters = array();
                 foreach ($possibleFirstNames as $i => $firstName) {
                     foreach ($possibleLastNames as $j => $lastName) {
                         $where[] = sprintf("(%s LIKE ? AND %s LIKE ?)", $this->getField('firstname'), $this->getField('lastname'));
                         $parameters[] = $firstName;
                         $parameters[] = $lastName;
                     }
                 }
                 $where = implode(" OR ", $where);
         }
         //build search for additional fields
         if ($searchField = $this->getSearchFields()) {
             $fieldWhere = array();
             foreach ($searchField as $field) {
                 $fieldWhere[] = sprintf("%s LIKE ?", $field);
                 $parameters[] = "%" . $searchString . "%";
             }
             $where .= ' OR ' . implode(" OR ", $fieldWhere);
         }
         $sql = sprintf("SELECT %s FROM %s WHERE %s ORDER BY %s", '*', $this->table, $where, implode(",", array_map(array($this, 'getField'), $this->sortFields)));
     } else {
         $this->errorMsg = "Invalid query";
         return false;
     }
     return array($sql, $parameters);
 }

    /**
     * Sees if the given user matches the rule
     * @param User $user a valid user object
	 * @return mixed, the action if the user matches the rule or false if the rule did not match
     */
    public function evaluateForUser(User $user)
    {
        switch ($this->ruleType)
        {
            case self::RULE_TYPE_AUTHORITY:
                /* if the value is all then see if the userID and authority are set and it's a MATCH
                   this will NOT match an anonymous user 
                */
                if ($this->ruleValue==self::RULE_VALUE_ALL) {
                    if ($user->getUserID() && $user->getAuthenticationAuthority()) {
                        return $this->ruleAction;
                    }

                /* Otherwise see if the userID is set and the authority matches the rule value */
                } elseif ($user->getUserID() && $user->getAuthenticationAuthorityIndex()==$this->ruleValue) {
                    return $this->ruleAction;
                }
                
                break;
            case self::RULE_TYPE_USER:
                /* if the value is all then see if the userID is set
                   this will NOT match an anonymous user 
                */
                if ($this->ruleValue==self::RULE_VALUE_ALL) {
                    if ($user->getUserID()) {
                        return $this->ruleAction;
                    }
                } else { 
                    /* user values are specified as AUTHORITY|userID */
                    $values = explode("|", $this->ruleValue);
                    switch (count($values)) {
                        case 1:
                            $authority = AuthenticationAuthority::getDefaultAuthenticationAuthorityIndex();
                            $userID = $values[0];
                            break;
                        case 2:
                            $authority = $values[0];
                            $userID = $values[1];
                            break;
                    }
                    
                    /* see if the userID/email and authority match */
                    if ($user->getAuthenticationAuthorityIndex()==$authority) {
                        /* can match either userID or email */
                        if ($userID==self::RULE_VALUE_ALL) {
                            if ($user->getUserID()) {
                                return $this->ruleAction;
                            }
                        } else if ($user->getUserID()==$userID ||
                            (Validator::isValidEmail($userID) && $user->getEmail()==$userID)) { 
                            return $this->ruleAction;
                        }
                    }
                }
                break;
            case self::RULE_TYPE_GROUP:
                /* Note: a group value of ALL is not valid */

                /* group values are specified as AUTHORITY|group */
                $values = explode("|", $this->ruleValue);
                switch (count($values)) {
                    case 1:
                        $authority = AuthenticationAuthority::getDefaultAuthenticationAuthorityIndex();
                        $group = $values[0];
                        break;
                    case 2:
                        $authority = $values[0];
                        $group = $values[1];
                        break;
                }


                /* attempt to load the authority, then get the group */
                if ($authority = AuthenticationAuthority::getAuthenticationAuthority($authority)) {
                    if ($group = $authority->getGroup($group)) {

                        /* see if the user is a member of the group */
                        if ($group->userIsMember($user)) {
                            return $this->ruleAction;
                        }
                    }
                }
                
                break;
            case self::RULE_TYPE_EVERYONE:
                /* always matches */
                return $this->ruleAction;
                break;
        }
        
        return false;
    }