PHP Criteria::setIgnoreCase方法代码示例

 public static function search($query_string, $sf_user, $limit = 12)
 {
     $query_string = trim($query_string);
     if (!is_null($query_string) && !empty($query_string) && '' != $query_string && strlen($query_string) > 3) {
         $criteria = new Criteria();
         $criteria->setIgnoreCase(true);
         $criteria->setLimit($limit);
         $criteria->add(SchoolYearStudentPeer::SCHOOL_YEAR_ID, SchoolYearPeer::retrieveCurrent()->getId());
         $criteria->addJoin(SchoolYearStudentPeer::STUDENT_ID, self::ID);
         $criteria->addJoin(self::PERSON_ID, PersonPeer::ID, Criteria::INNER_JOIN);
         $criteria->addAscendingOrderByColumn(PersonPeer::LASTNAME);
         if (is_numeric($query_string)) {
             // Search by identification number
             $criteria->add(PersonPeer::IDENTIFICATION_NUMBER, $query_string . '%', Criteria::LIKE);
         } else {
             // Search by firstname or lastname
             $criterion = $criteria->getNewCriterion(PersonPeer::FIRSTNAME, $query_string . '%', Criteria::LIKE);
             $criterion->addOr($criteria->getNewCriterion(PersonPeer::LASTNAME, $query_string . '%', Criteria::LIKE));
             $criteria->add($criterion);
         }
         if ($sf_user->isPreceptor()) {
             PersonalPeer::joinWithStudents($criteria, $sf_user->getGuardUser()->getId());
         } elseif ($sf_user->isTeacher()) {
             TeacherPeer::joinWithStudents($criteria, $sf_user->getGuardUser()->getId());
         }
         //FALTA HEAD PRECEPTOR
         return self::doSelectActive($criteria);
     }
     return array();
 }

 public static function retrieveByUuid($value)
 {
     $c = new Criteria();
     $c->add(self::UUID, $value);
     $c->setIgnoreCase(true);
     return self::doSelectOne($c);
 }

 public function addWordColumnCriteria(Criteria $criteria, $field, $value)
 {
     $value = "%{$value}%";
     $criteria->setIgnoreCase(true);
     $criterion = $criteria->getNewCriterion(SubjectPeer::NAME, $value, Criteria::LIKE);
     $criterion->addOr($criteria->getNewCriterion(SubjectPeer::FANTASY_NAME, $value, Criteria::LIKE));
     $criteria->add($criterion);
 }

 public static function getNbFiles($entity, $entity_id)
 {
     $c = new Criteria();
     $c->add(sfFileGalleryPeer::ENTITY, $entity);
     $c->add(sfFileGalleryPeer::ENTITY_ID, $entity_id);
     $c->setIgnoreCase(true);
     return sfFileGalleryPeer::doCount($c);
 }

 public function getByName($name)
 {
     $c = new Criteria();
     $c->add(NagiosTimeperiodPeer::NAME, $name);
     $c->setIgnoreCase(true);
     $timeperiod = NagiosTimeperiodPeer::doSelectOne($c);
     if (!$timeperiod) {
         return false;
     }
     return $timeperiod;
 }

 public function getByName($name)
 {
     $c = new Criteria();
     $c->add(NagiosHostTemplatePeer::NAME, $name);
     $c->setIgnoreCase(true);
     $template = NagiosHostTemplatePeer::doSelectOne($c);
     if (!$template) {
         return false;
     }
     return $template;
 }

 public function getByName($name)
 {
     $c = new Criteria();
     $c->add(NagiosContactPeer::NAME, $name);
     $c->setIgnoreCase(true);
     $contact = NagiosContactPeer::doSelectOne($c);
     if (!$contact) {
         return false;
     }
     return $contact;
 }

 public function getByName($name)
 {
     $c = new Criteria();
     $c->add(NagiosHostgroupPeer::NAME, $name);
     $c->setIgnoreCase(true);
     $hostgroup = NagiosHostgroupPeer::doSelectOne($c);
     if (!$hostgroup) {
         return false;
     }
     return $hostgroup;
 }

 public function import()
 {
     $job = $this->getEngine()->getJob();
     $config = $this->getEngine()->getConfig();
     $command = new NagiosCommand();
     $segment = $this->getSegment();
     // First check if we have a use
     $useTemplate = $segment->get("use");
     if ($useTemplate) {
         // Okay, we need to check to see if we have an existing dependency
         $val = $useTemplate[0]['value'];
         $c = new Criteria();
         $c->add(NagiosCommandPeer::NAME, $val);
         $c->setIgnoreCase(true);
         $dependant = NagiosCommandPeer::doSelectOne($c);
         if ($dependant) {
             $command->setLine($dependant->getLine());
         }
         $dependant->clearAllReferences(true);
     }
     $values = $segment->getValues();
     $fileName = $segment->getFilename();
     $commandLine = array();
     foreach ($values as $key => $entries) {
         foreach ($entries as $entry) {
             $value = $entry['value'];
             $lineNum = $entry['line'];
             if (key_exists($key, $this->fieldMethods) && $this->fieldMethods[$key] != '') {
                 if ($key == "command_line") {
                     // Combine into our line array
                     $commandLine[] = $value;
                     continue;
                 }
                 // Okay, let's check that the method DOES exist
                 if (!method_exists($command, $this->fieldMethods[$key])) {
                     $job->addError("Method " . $this->fieldMethods[$key] . " does not exist for variable: " . $key . " on line " . $lineNum . " in file " . $fileName);
                     if (!$config->getVar('continue_error')) {
                         return false;
                     }
                 } else {
                     call_user_method($this->fieldMethods[$key], $command, $value);
                 }
             }
         }
     }
     // re-assemble command
     $commandLine = implode(',', $commandLine);
     $command->setLine($commandLine);
     $command->save();
     $command->clearAllReferences(true);
     $job->addNotice("NagiosCommandImporter finished importing command: " . $command->getName());
     return true;
 }

 public function addUsernameColumnCriteria(Criteria $criteria, $field, $value)
 {
     $value = trim($value);
     if ($value != '') {
         $value = "%{$value}%";
         $criteria->setIgnoreCase(true);
         $criteria->addJoin(TeacherPeer::PERSON_ID, PersonPeer::ID);
         $criteria->addJoin(PersonPeer::USER_ID, sfGuardUserPeer::ID);
         $criterion = $criteria->getNewCriterion(sfGuardUserPeer::USERNAME, $value, Criteria::LIKE);
         $criteria->add($criterion);
     }
 }

 public static function retrievePager($c = null, $page = 1, $max = 10)
 {
     if ($c == null) {
         $c = new Criteria();
     }
     $c->addDescendingOrderByColumn(self::LAST_NAME);
     $c->setIgnoreCase(true);
     $pager = new sfPropelPager('sfGuardUserProfile', $max);
     $pager->setCriteria($c);
     $pager->setPeerMethod('doSelectJoinSfGuardUser');
     $pager->setPage($page);
     $pager->init();
     return $pager;
 }

 public static function getLightboxArray($entity, $entity_id)
 {
     $images = array();
     $c = new Criteria();
     $c->add(sfPhotoGalleryPeer::ENTITY, $entity);
     $c->add(sfPhotoGalleryPeer::ENTITY_ID, $entity_id);
     $c->setIgnoreCase(true);
     $photos = sfPhotoGalleryPeer::doSelect($c);
     if (count($photos) > 0) {
         foreach ($photos as $photo) {
             $images[] = array('real_name' => $photo->getRealName(), 'options' => array('title' => $photo->getDescription()));
         }
     }
     return $images;
 }

 public static function retrieveByEmail($value)
 {
     $data = split('@', $value);
     $email = $data[1];
     $c = new Criteria();
     $c->add(self::EMAIL, $email);
     $c->setIgnoreCase(true);
     $result = self::doSelectOne($c);
     if ($result == null) {
         sfContext::getInstance()->getLogger()->log('no matching email domain for (' . $email . ')');
         return false;
     }
     sfContext::getInstance()->getLogger()->log('matching email domain found');
     return $result;
 }

 public static function getByHostTemplateAndDescription($hostTemplateName, $description)
 {
     // First get host template
     $template = NagiosHostTemplatePeer::getByName($hostTemplateName);
     if (!$template) {
         return false;
     }
     $c = new Criteria();
     $c->add(NagiosServicePeer::HOST_TEMPLATE, $template->getId());
     $c->add(NagiosServicePeer::DESCRIPTION, $description);
     $c->setIgnoreCase(true);
     $service = NagiosServicePeer::doSelectOne($c);
     if (!$service) {
         return false;
     }
     return $service;
 }

 public static function retrievePager($c = null, $page = 1, $max = null)
 {
     if ($c == null) {
         $c = new Criteria();
     }
     if ($max == null) {
         $max = sfConfig::get('app_pager_project_max');
     }
     $c->addDescendingOrderByColumn(ProjectPeer::CREATED_AT);
     $c->setIgnoreCase(true);
     $pager = new sfPropelPager('Project', $max);
     $pager->setCriteria($c);
     //$pager->setPeerMethod('doSelectJoinSfGuardUserRelatedByOwnerId');
     $pager->setPage($page);
     $pager->init();
     return $pager;
 }