PHP _daoSp函数代码示例

 /**
  * Retourne un user selon un identifiant
  *
  * @param string $login
  *
  * @return DAORecordDBUser or false
  */
 public function getByUserLogin($login)
 {
     $criteria = _daoSp();
     $criteria->addCondition('login_dbuser', '=', $login);
     $results = $this->findBy($criteria);
     return isset($results[0]) ? $results[0] : false;
 }

 /**
  * Retourne l'année scolaire courante
  *
  * @return DAORecordKernel_bu_annee_scolaire
  */
 public function getCurrent()
 {
     $criteria = _daoSp();
     $criteria->addCondition('current', '=', 1);
     $results = $this->findBy($criteria);
     return isset($results[0]) ? $results[0] : false;
 }

 public function _createContent(&$toReturn)
 {
     $ppo = new CopixPPO();
     $ppo->conf = new CopixPPO();
     $ppo->conf->directorGlobalAffectation = CopixConfig::get('gestionautonome|directorGlobalAffectation');
     // Récupérations des filtres en session
     $ppo->selected = $this->getParam('selected', 0);
     $ppo->withLabel = $this->getParam('with_label', true);
     $ppo->withEmpty = $this->getParam('with_empty', true);
     $ppo->labelEmpty = $this->getParam('label_empty', null);
     $ppo->name = $this->getParam('name', null);
     $ppo->cityGroupsIds = array();
     $ppo->cityGroupsNames = array();
     $citiesGroupDAO = _ioDAO('kernel|kernel_bu_groupe_villes');
     if (_currentUser()->testCredential('module:*||cities_group|create@gestionautonome') || _currentUser()->isDirector && $ppo->conf->directorGlobalAffectation) {
         $criteria = _daoSp();
         $criteria->orderBy('nom_groupe');
         $cityGroups = $citiesGroupDAO->findBy($criteria);
     } else {
         $groups = _currentUser()->getGroups();
         $cityGroups = $citiesGroupDAO->findByUserGroups($groups['gestionautonome|iconitogrouphandler']);
     }
     foreach ($cityGroups as $cityGroup) {
         $ppo->cityGroupsIds[] = $cityGroup->id_grv;
         $ppo->cityGroupsNames[] = $cityGroup->nom_groupe;
     }
     $toReturn = $this->_usePPO($ppo, '_filter_groupcity.tpl');
 }

 /**
  * Renvoie les infos de la dernière connexion d'un login
  *
  * @author Frédéric Mossmann <fmossmann@cap-tic.fr>
  * @since 2006/05/10
  * @param string $login Login de l'utilisateur
  * @return mixed Objet DAO
  */
 public function lastLogin($login)
 {
     $dao = _dao("logs|logs");
     $criteres = _daoSp();
     $criteres->addCondition('logs_type', '=', 'LOG');
     $criteres->addCondition('logs_mod_name', '=', 'auth');
     $criteres->addCondition('logs_mod_action', '=', 'in');
     $criteres->addCondition('logs_message', '=', 'Login ok: ' . $login);
     $criteres->orderBy(array('logs_date', 'DESC'));
     $lastlog = $dao->findBy($criteres);
     $criteres = _daoSp();
     $criteres->addCondition('logs_type', '=', 'LOG');
     $criteres->addCondition('logs_mod_name', '=', 'auth');
     $criteres->addCondition('logs_mod_action', '=', 'in');
     $criteres->addCondition('logs_message', ' LIKE ', 'Login failed: ' . $login . '/%');
     $criteres->orderBy(array('logs_date', 'DESC'));
     $lastfailed = $dao->findBy($criteres);
     $return = false;
     if (sizeof($lastlog) > 0) {
         $return['nb'] = sizeof($lastlog);
         $return['last'] = $lastlog[0];
         if (sizeof($lastfailed) > 0) {
             $return['failed'] = $lastfailed[0];
         }
     }
     return $return;
 }

 /**
  * Retourne les domaines d'une classe
  *
  * @param int $idClasse Identifiant d'une classe
  *
  * @return CopixDAORecordIterator
  */
 public function findByClasse($idClasse)
 {
     $criteria = _daoSp();
     $criteria->addCondition('classe_id', '=', $idClasse);
     $criteria->orderBy(array('nom', 'ASC'));
     return $this->findBy($criteria);
 }

 /**
  * Retourne les classes pour une ville donnée
  *
  * @param int $idVille Identifiant d'une ville
  *
  * @return CopixDAORecordIterator
  */
 public function getByCity($idVille)
 {
     $criteria = _daoSp();
     $criteria->addCondition('id_ville', '=', $idVille);
     $criteria->orderBy('nom');
     return $this->findBy($criteria);
 }

 /**
  * Retourne les mots pour un catalogue et une langue donnée
  *
  * @param int     $vocabularyCatalogId
  * @param string  $lang
  *
  * @return CopixDAORecordIterator
  */
 public function findByCatalogAndLang($vocabularyCatalogId, $lang)
 {
     $criteria = _daoSp();
     $criteria->addCondition('vocabulary_catalog_id', '=', $vocabularyCatalogId);
     $criteria->addCondition('lang_word', '=', $lang);
     return $this->findBy($criteria);
 }

 public function _createContent(&$toReturn)
 {
     $tpl = new CopixTpl();
     $blog = $this->getParam('blog', '');
     $cat = $this->getParam('cat', null);
     $critere = $this->getParam('critere', null);
     //on récupère l'ensemble des articles du blog
     $dao = _dao('blog|blogarticle');
     if ($cat == null) {
         $date = $this->getParam('date', null);
         $arData = $dao->getAllArticlesFromBlog($blog->id_blog, $date);
     } else {
         $arData = $dao->getAllArticlesFromBlogByCat($blog->id_blog, $cat->id_bacg);
         $tpl->assign('cat', $cat);
     }
     //on filtre si on a fait une recherche sur les articles
     if ($critere != null) {
         $arData = $dao->getAllArticlesFromBlogByCritere($blog->id_blog, $critere);
     }
     //var_dump($arData);
     //on construit un tableau associatif entre l'identifiant de l'article et le nombre de commentaires
     foreach ($arData as $article) {
         //var_dump($article);
         $daoArticleComment =& CopixDAOFactory::getInstanceOf('blog|blogarticlecomment');
         $record = _record('blog|blogarticlecomment');
         $criteres = _daoSp();
         $criteres->addCondition('id_bact', '=', $article->id_bact);
         $criteres->addCondition('is_online', '=', 1);
         $resultat = $daoArticleComment->findBy($criteres);
         $arNbCommentByArticle[$article->id_bact] = count($resultat);
     }
     if (count($arData) > 0) {
         //encodage des URL des catégories pour caractères spéciaux
         foreach ($arData as $key => $data) {
             //Modification suite à apparition d'un warning due à l'absence de catégories , vboniface 06.11.2006
             $arData[$key]->key = $key;
             if (isset($arData[$key]->categories)) {
                 foreach ($arData[$key]->categories as $keyCat => $categorie) {
                     $arData[$key]->categories[$keyCat]->url_bacg = urlencode($categorie->url_bacg);
                 }
             }
         }
         if (count($arData) <= intval(CopixConfig::get('blog|nbMaxArticles'))) {
             $tpl->assign('pager', "");
             $tpl->assign('listArticle', $arData);
             $tpl->assign('arNbCommentByArticle', $arNbCommentByArticle);
         } else {
             $params = array('perPage' => intval(CopixConfig::get('blog|nbMaxArticles')), 'delta' => 5, 'recordSet' => $arData, 'template' => '|pager.tpl');
             $Pager = CopixPager::Load($params);
             $tpl->assign('pager', $Pager->GetMultipage());
             $tpl->assign('listArticle', $Pager->data);
             $tpl->assign('arNbCommentByArticle', $arNbCommentByArticle);
         }
         //rajout suite à bug mantis 54 vboniface 06.11.2006
         $tpl->assign('blog', $blog);
     }
     // retour de la fonction :
     $toReturn = $tpl->fetch('listarticle.tpl');
     return true;
 }

 /**
  * Retourne le catalogue de vocabulaire à partir de son nom
  *
  * @return DAORecordKernel_i18n_vocabulary_catalog or false
  */
 public function findByName($name)
 {
     $criteria = _daoSp();
     $criteria->addCondition('name_vc', '=', $name);
     $results = $this->findBy($criteria);
     return isset($results[0]) ? $results[0] : false;
 }

 /**
  * Visualisation de l'aide
  *
  * @param string $toReturn
  * @return string
  */
 public function _createContent(&$toReturn)
 {
     $tpl = new CopixTpl();
     $displayAide = true;
     $daoAide = _ioDao('simplehelp');
     $sp = _daoSp()->addCondition('page_sh', '=', $this->getParam('page_sh', null, null))->addCondition('key_sh', '=', $this->getParam('key_sh', null, null));
     $arAide = $daoAide->findBy($sp);
     if (count($arAide) > 0) {
         $aide = $arAide[0];
     } else {
         $displayAide = false;
         $aide = null;
     }
     // cette variable est crée pour différencier si l'aide doit être afficher dans un popup classique ou un popuinformation
     $popup = false;
     if ($this->getParam('popup', null, true) === "true") {
         $popup = true;
     }
     $tpl->assign('aide', $aide);
     $tpl->assign('displayAide', $displayAide);
     $tpl->assign('popup', $popup);
     // $tpl->assign ('nofloat', $this->getParam ('nofloat', false));
     $toReturn = $tpl->fetch('showaide.tpl');
     return true;
 }

 /**
  * Retourne le lien d'un travail avec un élève
  *
  * @param int $travailId Identifiant du travail
  * @param int $eleveId   Identifiant de l'élève
  *
  * @return DAORecordCahierDeTextesTravail2eleve or false
  */
 public function getByTravailAndEleve($travailId, $eleveId)
 {
     $criteria = _daoSp();
     $criteria->addCondition('travail_id', '=', $travailId);
     $criteria->addCondition('eleve_id', '=', $eleveId);
     $results = $this->findBy($criteria);
     return isset($results[0]) ? $results[0] : false;
 }

 /**
  * Get all article from a blog
  */
 public function getAllPagesFromBlog($id_blog)
 {
     $sp = _daoSp();
     $sp->addCondition('id_blog', '=', $id_blog);
     $sp->addCondition('is_online', '=', 1);
     $sp->orderBy('order_bpge');
     return $this->findBy($sp);
 }

 public function testOffsetExistsDAO()
 {
     $results = _ioDao('copix:copixconfig')->iFindBy(_daoSp()->addCondition('id_ccfg', '=', 'FOOOOOOOOOOOOVALUE'));
     $this->assertFalse(isset($results[0]));
     $results = _ioDAO('copix:copixconfig')->iFindAll();
     $this->assertTrue(count($results) > 10);
     $this->assertTrue(isset($results[0]));
 }

 /**
  * Retourne les événements d'un agenda pour un intervalle donné
  *
  * @param integer  $agendaId    Identifiant de l'agenda
  * @param string   $dateDebut   Date de début de l'intervalle (format Ymd)
  * @param string   $dateFin     Date de fin de l'intervalle (format Ymd)
  *
  * @return CopixDAORecordIterator
  */
 public function findByAgendaAndDateInterval($agendaId, $dateDebut, $dateFin)
 {
     $c = _daoSp();
     $c->addCondition('id_agenda', '=', $agendaId);
     $c->addCondition('datedeb_event', '<=', $dateFin);
     $c->startGroup();
     $c->addCondition('datefin_event', '>=', $dateDebut);
     $c->addCondition('endrepeatdate_event', '>=', $dateDebut, 'or');
     $c->endGroup();
     return $this->findBy($c);
 }

 /**
  * Retourne l'admission pour un élève et une école
  *
  * @param int $studentId  Identifiant d'un élève
  * @param int $schoolId   Identifiant d'une école
  *
  * @return DAORecord
  */
 public function getByStudentAndSchool($studentId, $schoolId, $state = null)
 {
     $criteria = _daoSp();
     $criteria->addCondition('admission_eleve', '=', $studentId);
     $criteria->addCondition('admission_etablissement', '=', $schoolId);
     if (!is_null($state)) {
         $criteria->addCondition('admission_etat_eleve', '=', $state);
     }
     $results = $this->findBy($criteria);
     return isset($results[0]) ? $results[0] : false;
 }