public function execute($request)
 {
     if (!isset($request->limit)) {
         $request->limit = sfConfig::get('app_hits_per_page');
     }
     $criteria = new Criteria();
     switch ($request->sort) {
         case 'nameDown':
             $criteria->addDescendingOrderByColumn('authorized_form_of_name');
             break;
         case 'nameUp':
             $criteria->addAscendingOrderByColumn('authorized_form_of_name');
             break;
         case 'updatedDown':
             $criteria->addDescendingOrderByColumn(QubitObject::UPDATED_AT);
             break;
         case 'updatedUp':
             $criteria->addAscendingOrderByColumn(QubitObject::UPDATED_AT);
             break;
         default:
             if (!$this->getUser()->isAuthenticated()) {
                 $criteria->addAscendingOrderByColumn('authorized_form_of_name');
             } else {
                 $criteria->addDescendingOrderByColumn(QubitObject::UPDATED_AT);
             }
     }
     // Do source culture fallback
     $criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitFunction');
     // Page results
     $this->pager = new QubitPager('QubitFunction');
     $this->pager->setCriteria($criteria);
     $this->pager->setMaxPerPage($request->limit);
     $this->pager->setPage($request->page);
 }
 public function execute($request)
 {
     if (!$this->context->user->hasCredential(array('contributor', 'editor', 'administrator'), false)) {
         QubitAcl::forwardUnauthorized();
     }
     if (!isset($request->limit)) {
         $request->limit = sfConfig::get('app_hits_per_page');
     }
     $criteria = new Criteria();
     switch ($request->sort) {
         case 'nameDown':
             $criteria->addDescendingOrderByColumn('identifier');
             break;
         case 'nameUp':
             $criteria->addAscendingOrderByColumn('identifier');
             break;
         case 'updatedDown':
             $criteria->addDescendingOrderByColumn(QubitObject::UPDATED_AT);
             break;
         case 'updatedUp':
             $criteria->addAscendingOrderByColumn(QubitObject::UPDATED_AT);
             break;
         default:
             if (!$this->getUser()->isAuthenticated()) {
                 $criteria->addAscendingOrderByColumn('authorized_form_of_name');
             } else {
                 $criteria->addDescendingOrderByColumn(QubitObject::UPDATED_AT);
             }
     }
     // Page results
     $this->pager = new QubitPager('QubitAccession');
     $this->pager->setCriteria($criteria);
     $this->pager->setMaxPerPage($request->limit);
     $this->pager->setPage($request->page);
 }
 public function getOrderedStudentExaminationRepprovedSubjects()
 {
     $c = new Criteria();
     $c->addAscendingOrderByColumn(StudentExaminationRepprovedSubjectPeer::MARK);
     $c->addAscendingOrderByColumn(StudentExaminationRepprovedSubjectPeer::DATE);
     return $this->getStudentExaminationRepprovedSubjects($c);
 }
 public function execute($request)
 {
     $this->resource = $request->getAttribute('sf_route')->resource;
     $criteria = new Criteria();
     $criteria->add(QubitEvent::ACTOR_ID, $this->resource->id);
     $criteria->addJoin(QubitEvent::INFORMATION_OBJECT_ID, QubitInformationObject::ID);
     $criteria->addAscendingOrderByColumn(QubitEvent::TYPE_ID);
     // Sort info objects alphabetically (w/ fallback)
     $criteria->addAscendingOrderByColumn('title');
     $criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitInformationObject');
     // Filter draft descriptions
     $criteria = QubitAcl::addFilterDraftsCriteria($criteria);
     $this->relatedInfoObjects = array();
     foreach (QubitEvent::get($criteria) as $item) {
         $this->relatedInfoObjects[$item->type->getRole()][] = $item->informationObject;
     }
     // Get "subject of" information objects (name access point)
     $criteria = new Criteria();
     $criteria->add(QubitRelation::OBJECT_ID, $this->resource->id);
     $criteria->add(QubitRelation::TYPE_ID, QubitTerm::NAME_ACCESS_POINT_ID);
     $this->subjectInfoObjects = array();
     foreach (QubitRelation::get($criteria) as $item) {
         $this->subjectInfoObjects[] = $item->subject;
     }
 }
 public function execute($request)
 {
     parent::execute($request);
     $this->permissions = array();
     if (null != $this->resource->id) {
         // Get term permissions for this group
         $criteria = new Criteria();
         $criteria->addJoin(QubitAclPermission::OBJECT_ID, QubitObject::ID, Criteria::LEFT_JOIN);
         $criteria->add(QubitAclPermission::GROUP_ID, $this->resource->id);
         $c1 = $criteria->getNewCriterion(QubitAclPermission::OBJECT_ID, null, Criteria::ISNULL);
         $c2 = $criteria->getNewCriterion(QubitObject::CLASS_NAME, 'QubitTerm');
         $c1->addOr($c2);
         $criteria->add($c1);
         $criteria->addAscendingOrderByColumn(QubitAclPermission::CONSTANTS);
         $criteria->addAscendingOrderByColumn(QubitAclPermission::OBJECT_ID);
         if (0 < count($permissions = QubitAclPermission::get($criteria))) {
             $this->permissions = $permissions;
         }
     }
     // List of actions without create or translate
     $this->basicActions = QubitAcl::$ACTIONS;
     unset($this->basicActions['read']);
     unset($this->basicActions['translate']);
     if ($request->isMethod('post')) {
         $this->form->bind($request->getPostParameters());
         if ($this->form->isValid()) {
             $this->processForm();
             $this->redirect(array($this->resource, 'module' => 'aclGroup', 'action' => 'indexTermAcl'));
         }
     }
 }
Example #6
0
 public static function doSelectOrdered()
 {
     $criteria = new Criteria();
     $criteria->addAscendingOrderByColumn(EmployeePeer::EMP_NO);
     $criteria->addAscendingOrderByColumn(EmployeePeer::NAME);
     return EmployeePeer::doSelect($criteria);
 }
 public function execute($request)
 {
     if (!isset($request->limit)) {
         $request->limit = sfConfig::get('app_hits_per_page');
     }
     $criteria = new Criteria();
     if (isset($this->getRoute()->resource)) {
         $this->resource = $this->getRoute()->resource;
         $criteria->add(QubitInformationObject::PARENT_ID, $this->resource->id);
     } else {
         $criteria->add(QubitInformationObject::PARENT_ID, QubitInformationObject::ROOT_ID);
     }
     if (isset($request->repositoryId)) {
         $criteria->add(QubitInformationObject::REPOSITORY_ID, $request->repositoryId);
     }
     if (isset($request->collectionType)) {
         $criteria->add(QubitInformationObject::COLLECTION_TYPE_ID, $request->collectionType);
     }
     $fallbackTable = 'QubitInformationObject';
     switch ($request->sort) {
         case 'repositoryDown':
             $fallbackTable = 'QubitActor';
             $criteria->addJoin(QubitInformationObject::REPOSITORY_ID, QubitActor::ID, Criteria::LEFT_JOIN);
             $criteria->addDescendingOrderByColumn('authorized_form_of_name');
             break;
         case 'repositoryUp':
             $fallbackTable = 'QubitActor';
             $criteria->addJoin(QubitInformationObject::REPOSITORY_ID, QubitActor::ID, Criteria::LEFT_JOIN);
             $criteria->addAscendingOrderByColumn('authorized_form_of_name');
             break;
         case 'titleDown':
             $criteria->addDescendingOrderByColumn('title');
             break;
         case 'titleUp':
             $criteria->addAscendingOrderByColumn('title');
             break;
         case 'updatedDown':
             $criteria->addDescendingOrderByColumn(QubitObject::UPDATED_AT);
             break;
         case 'updatedUp':
             $criteria->addAscendingOrderByColumn(QubitObject::UPDATED_AT);
             break;
         default:
             if (!$this->getUser()->isAuthenticated()) {
                 $criteria->addAscendingOrderByColumn('title');
             } else {
                 $criteria->addDescendingOrderByColumn(QubitObject::UPDATED_AT);
             }
     }
     // Do source culture fallback
     $criteria = QubitCultureFallback::addFallbackCriteria($criteria, $fallbackTable);
     // Filter drafts
     $criteria = QubitAcl::addFilterDraftsCriteria($criteria);
     // Page results
     $this->pager = new QubitPager('QubitInformationObject');
     $this->pager->setCriteria($criteria);
     $this->pager->setMaxPerPage($request->limit);
     $this->pager->setPage($request->page);
 }
 public static function getAllOrderedByCategory()
 {
     $c = new Criteria();
     $c->addJoin(self::CATEGORY_ID, sfSimpleForumCategoryPeer::ID);
     $c->addAscendingOrderByColumn(sfSimpleForumCategoryPeer::RANK);
     $c->addAscendingOrderByColumn(self::RANK);
     return self::doSelectJoinCategoryLeftJoinPost($c);
 }
Example #9
0
 public function getMatriculats()
 {
     $C = new Criteria();
     $C->addAscendingOrderByColumn(MatriculesPeer::ESTAT);
     $C->addAscendingOrderByColumn(MatriculesPeer::DATAINSCRIPCIO);
     //$C->add(MatriculesPeer::CURSOS_IDCURSOS, $this->getIdcursos());
     return $this->getMatriculess($C);
 }
 public function executeList()
 {
     $c = new Criteria();
     $c->addAscendingOrderByColumn(PodcastPeer::TITLE);
     $c->addAscendingOrderByColumn(PodcastPeer::UPDATED_AT);
     $c->addAscendingOrderByColumn(PodcastPeer::CREATED_AT);
     $this->podcasts = PodcastPeer::doSelect($c);
 }
Example #11
0
 public static function doSelectJoinAnioByOrden(Criteria $c, $con = null, $join_behavior = Criteria::LEFT_JOIN)
 {
     //      $c->addAscendingOrderByColumn(AnioPeer::ORDEN);
     $c->addAscendingOrderByColumn(AnioPeer::DESCRIPCION);
     $c->addAscendingOrderByColumn(DivisionPeer::ORDEN);
     $c->addAscendingOrderByColumn(DivisionPeer::DESCRIPCION);
     return DivisionPeer::doSelectJoinAnio($c);
 }
 public function execute($request)
 {
     $this->resource = $this->getRoute()->resource;
     // Except for administrators, only allow users to see their own profile
     if (!$this->context->user->hasCredential('administrator')) {
         if ($this->resource->id != $this->context->user->getAttribute('user_id')) {
             $this->redirect('admin/secure');
         }
     }
     // Get user's groups
     $this->userGroups = array();
     if (0 < count($aclUserGroups = $this->resource->aclUserGroups)) {
         foreach ($aclUserGroups as $aclUserGroup) {
             $this->userGroups[] = $aclUserGroup->groupId;
         }
     } else {
         // User is *always* part of authenticated group
         $this->userGroups = array(QubitAclGroup::AUTHENTICATED_ID);
     }
     // Table width
     $this->tableCols = count($this->userGroups) + 3;
     // Get access control permissions
     $criteria = new Criteria();
     $criteria->addJoin(QubitAclPermission::OBJECT_ID, QubitObject::ID, Criteria::LEFT_JOIN);
     $c1 = $criteria->getNewCriterion(QubitAclPermission::USER_ID, $this->resource->id);
     // Add group criteria
     if (1 == count($this->userGroups)) {
         $c2 = $criteria->getNewCriterion(QubitAclPermission::GROUP_ID, $this->userGroups[0]);
     } else {
         $c2 = $criteria->getNewCriterion(QubitAclPermission::GROUP_ID, $this->userGroups, Criteria::IN);
     }
     $c1->addOr($c2);
     // Add info object criteria
     $c3 = $criteria->getNewCriterion(QubitObject::CLASS_NAME, 'QubitInformationObject');
     $c4 = $criteria->getNewCriterion(QubitAclPermission::OBJECT_ID, null, Criteria::ISNULL);
     $c3->addOr($c4);
     $c1->addAnd($c3);
     $criteria->add($c1);
     // Sort
     $criteria->addAscendingOrderByColumn(QubitAclPermission::CONSTANTS);
     $criteria->addAscendingOrderByColumn(QubitAclPermission::OBJECT_ID);
     $criteria->addAscendingOrderByColumn(QubitAclPermission::USER_ID);
     $criteria->addAscendingOrderByColumn(QubitAclPermission::GROUP_ID);
     // Add user as final "group"
     $this->userGroups[] = $this->resource->username;
     // Build ACL
     $this->acl = array();
     if (0 < count($permissions = QubitAclPermission::get($criteria))) {
         foreach ($permissions as $item) {
             // In this context permissions for all objects (null) and root actor
             // object are equivalent
             $objectId = QubitInformationObject::ROOT_ID != $item->objectId ? $item->objectId : null;
             // Use username as "group" for permissions specific to user
             $groupKey = null !== $item->groupId ? $item->groupId : $this->resource->username;
             $this->acl[$item->getConstants(array('name' => 'repositoryId'))][$objectId][$item->action][$groupKey] = $item;
         }
     }
 }
Example #13
0
 public function executeList()
 {
     $c = new Criteria();
     //$c->add(DesignationPeer::TITLE, 'None', Criteria::NOT_EQUAL);
     $c->add(DesignationPeer::STATUS, Constant::RECORD_STATUS_DELETED, Criteria::NOT_EQUAL);
     $c->addAscendingOrderByColumn(DesignationPeer::DEPARTMENT_ID);
     $c->addAscendingOrderByColumn(DesignationPeer::TITLE);
     $this->designations = DesignationPeer::doSelect($c);
 }
Example #14
0
 public static function retrieveSorted(Criteria $criteria = null, PropelPDO $con = null)
 {
     if (null === $criteria) {
         $criteria = new Criteria();
     }
     $criteria->addAscendingOrderByColumn(self::LAST_NAME);
     $criteria->addAscendingOrderByColumn(self::FIRST_NAME);
     return self::doSelect($criteria, $con);
 }
Example #15
0
 public function executeList()
 {
     $c = new Criteria();
     //$c->add(WardBedPeer::TITLE, 'None', Criteria::NOT_EQUAL);
     $c->add(WardBedPeer::STATUS, Constant::BED_DELETE, Criteria::NOT_EQUAL);
     $c->addAscendingOrderByColumn(WardBedPeer::WARD_ID);
     $c->addAscendingOrderByColumn(WardBedPeer::BED);
     $this->beds = WardBedPeer::doSelect($c);
 }
Example #16
0
 public function getJournalComments($oCriteria = null, PropelPDO $oConnection = null)
 {
     if ($oCriteria === null) {
         $oCriteria = new Criteria();
     }
     $oCriteria->addAscendingOrderByColumn(JournalCommentPeer::CREATED_AT);
     $oCriteria->addAscendingOrderByColumn(JournalCommentPeer::ID);
     return parent::getJournalComments($oCriteria, $oConnection);
 }
Example #17
0
 /**
  * Función que devuelve una lista con los estados de las tareas que son eventos.
  * @return array, lista de objetos de tipo parametro
  * @version 10-02-09
  * @author Ana Martín
  */
 public static function getAllEstadosEventos()
 {
     $c = new Criteria();
     $c->add(ParametroPeer::TIPOPARAMETRO, '_ESTADO_TAREA_');
     $c->add(ParametroPeer::SI_NO, 1);
     $c->addAscendingOrderByColumn(ParametroPeer::NUMERO);
     $c->addAscendingOrderByColumn(ParametroPeer::NOMBRE);
     $lista = ParametroPeer::doSelect($c);
     return $lista;
 }
Example #18
0
 public static function getSectionsForTerm($term, PropelPDO $propelConnection = null)
 {
     $c = new Criteria();
     $crit1 = $c->getNewCriterion(self::TERM, $term);
     $c->addAnd($crit1);
     $c->addAscendingOrderByColumn(self::COURSE_ID);
     $c->addAscendingOrderByColumn(self::SECTION_TYPE);
     $c->addAscendingOrderByColumn(self::SECTION_NUM);
     return self::doSelect($c, $propelConnection);
 }
Example #19
0
 public static function getByNamePhone($name = null, $phone = null)
 {
     $c = new Criteria();
     $c->addAscendingOrderByColumn(self::ID);
     $c->addAscendingOrderByColumn(self::NAME);
     $c->add(self::NAME, $name);
     if ($phone) {
         $c->add(self::PHONE, $phone);
     }
     return self::doSelectOne($c);
 }
 public static function sortedBySubject(Criteria $c = null)
 {
     if (is_null($c)) {
         $c = new Criteria();
     }
     $c->addJoin(self::CAREER_SUBJECT_ID, CareerSubjectPeer::ID);
     $c->addAscendingOrderByColumn(CareerSubjectPeer::YEAR);
     $c->addJoin(CareerSubjectPeer::SUBJECT_ID, SubjectPeer::ID);
     $c->addAscendingOrderByColumn(SubjectPeer::NAME);
     return $c;
 }
Example #21
0
 public static function getExamsForYearAndCourseId($courseId, $year, PropelPDO $propelConnection)
 {
     $c = new Criteria();
     $crit1 = $c->getNewCriterion(ExamPeer::COURSE_ID, $courseId);
     $crit2 = $c->getNewCriterion(ExamPeer::YEAR, $year);
     $c->addAnd($crit1);
     $c->addAnd($crit2);
     $c->addAscendingOrderByColumn(ExamPeer::TYPE);
     $c->addAscendingOrderByColumn(ExamPeer::DESCR);
     return ExamPeer::doSelect($c, $propelConnection);
 }
 public static function sorted(Criteria $criteria)
 {
     if (is_null($criteria)) {
         $criteria = new Criteria();
     }
     $criteria->addJoin(CareerSubjectPeer::ID, self::CAREER_SUBJECT_ID);
     $criteria->addJoin(CareerSubjectPeer::SUBJECT_ID, SubjectPeer::ID);
     $criteria->addAscendingOrderByColumn(CareerSubjectPeer::YEAR);
     $criteria->addAscendingOrderByColumn(self::INDEX_SORT);
     $criteria->addAscendingOrderByColumn(SubjectPeer::NAME);
 }
Example #23
0
 public static function getCriteriaForPathwayStudents(Criteria $criteria = null)
 {
     if ($criteria === null) {
         $criteria = new Criteria();
     }
     $criteria->addJoin(StudentPeer::PERSON_ID, PersonPeer::ID);
     //$criteria->addAscendingOrderByColumn(PathwayStudentPeer::YEAR);
     $criteria->addAscendingOrderByColumn(PersonPeer::LASTNAME);
     $criteria->addAscendingOrderByColumn(PersonPeer::FIRSTNAME);
     return $criteria;
 }
 protected function doSort()
 {
     if ($this->sortColumn) {
         $this->criteria->clearOrderByColumns();
         if ($this->sortDir === 'DESC') {
             $this->criteria->addDescendingOrderByColumn($this->sortColumn);
         } else {
             $this->criteria->addAscendingOrderByColumn($this->sortColumn);
         }
     }
 }
Example #25
0
 public static function getEnOrden($criteria = NULL)
 {
     if (!$criteria instanceof Criteria or is_null($criteria)) {
         $criteria = new Criteria();
     }
     //      $criteria->add(ProvinciaPeer::ESTA_BORRADO, false);    Pensado para borrado logico
     $criteria->addAscendingOrderByColumn(ProvinciaPeer::ORDEN);
     $criteria->addAscendingOrderByColumn(ProvinciaPeer::NOMBRE_CORTO);
     $criteria->addAscendingOrderByColumn(ProvinciaPeer::NOMBRE_LARGO);
     $provincias = ProvinciaPeer::doSelect($criteria);
     return $provincias;
 }
Example #26
0
 public function executeIndex(sfWebRequest $request)
 {
     $this->buildSubmenu($request);
     $id = $request->getParameter("id");
     $conn = Propel::getConnection();
     $this->courseObj = CoursePeer::retrieveByPK($id, $conn);
     if (!is_object($this->courseObj)) {
         $this->forward404();
     }
     // courseDetail
     $detList = $this->courseObj->getCourseDetails(null, $conn);
     if (count($detList) > 0) {
         $this->courseDetail = $detList[0];
     }
     // instructor
     $detList = CourseInstructorAssociationPeer::getLatestInstructorsForCourseId($this->courseObj->getId(), $conn);
     $newList = CourseInstructorAssociationPeer::getHistoricalInstructorsForCourseId($this->courseObj->getId(), $conn);
     if (count($detList) > 0) {
         $this->currentInstructorList = $detList;
         $this->pastInstructorList = $newList;
     }
     // program
     $detList = CourseDisciplineAssociationPeer::getRelatedDisciplinesForCourse($this->courseObj, $conn);
     if (count($detList) > 0) {
         $this->programList = $detList;
     }
     // full exam data
     $conn = Propel::getConnection();
     $c = new Criteria();
     $courseCrit = $c->getNewCriterion(ExamPeer::COURSE_ID, $this->courseObj->getId());
     $c->addAnd($courseCrit);
     $c->addAscendingOrderByColumn(ExamPeer::YEAR);
     $c->addAscendingOrderByColumn(ExamPeer::TYPE);
     $c->addAscendingOrderByColumn(ExamPeer::DESCR);
     $examData = ExamPeer::doSelect($c, $conn);
     // now splice the data up and send it to the frontend
     $this->examData = array();
     $year = "";
     $type = "";
     foreach ($examData as $exam) {
         if ($year != $exam->getYear()) {
             $year = $exam->getYear();
             $this->examData[$year] = array();
             $type = "";
         }
         if ($type != $exam->getType()) {
             $type = $exam->getType();
             $this->examData[$year][$type] = array();
         }
         $this->examData[$year][$type][] = $exam;
     }
 }
Example #27
0
 public static function getForSelectParent()
 {
     $c = new Criteria();
     $c->addAscendingOrderByColumn(self::ID);
     $c->addAscendingOrderByColumn(self::SOURCE_NAME);
     $sources = self::doSelect($c);
     $arr = array();
     $arr[0] = '-- select --';
     foreach ($sources as $source) {
         $arr[$source->getId()] = $source->getSourceName();
     }
     return $arr;
 }
Example #28
0
 public static function getForSelectParent()
 {
     $c = new Criteria();
     $c->addAscendingOrderByColumn(self::ID);
     $c->addAscendingOrderByColumn(self::CONTACT_TYPE_DESC);
     $types = self::doSelect($c);
     $arr = array();
     $arr[0] = '-- select --';
     foreach ($types as $type) {
         $arr[$type->getId()] = $type->getContactTypeDesc();
     }
     return $arr;
 }
 protected function execute($arguments = array(), $options = array())
 {
     // initialize the database connection
     $databaseManager = new sfDatabaseManager($this->configuration);
     $connection = $databaseManager->getDatabase($options['connection'] ? $options['connection'] : null)->getConnection();
     // add your code here
     $c = new Criteria();
     $c->addAscendingOrderByColumn(AbsenceTypePeer::VALUE);
     $c->addAscendingOrderByColumn(AbsenceTypePeer::ID);
     foreach (AbsenceTypePeer::doSelect($c) as $key => $absence_type) {
         $absence_type->setOrder($key);
         $absence_type->save();
     }
 }
 protected function getPager($feed_id)
 {
     $pager = new sfPropelPager('Torrent', 20);
     $pager->setPeerMethod('doSelectJoinAll');
     $c = new Criteria();
     $c->addAscendingOrderByColumn(TorrentPeer::UPDATED_AT);
     $c->addAscendingOrderByColumn(TorrentPeer::CREATED_AT);
     // todo exclude future
     if ($feed_id) {
         $c->add(TorrentPeer::FEED_ID, $feed_id);
     }
     $pager->setCriteria($c);
     $pager->setPage(1);
     return $pager;
 }