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)
{
$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)
{
if (!$this->getUser()->isAuthenticated()) {
QubitAcl::forwardUnauthorized();
}
if (!isset($request->limit)) {
$request->limit = sfConfig::get('app_hits_per_page');
}
$criteria = new Criteria();
// Do source culture fallback
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitPhysicalObject');
switch ($request->sort) {
case 'nameDown':
$criteria->addDescendingOrderByColumn('name');
break;
case 'locationDown':
$criteria->addDescendingOrderByColumn('location');
break;
case 'locationUp':
$criteria->addAscendingOrderByColumn('location');
break;
case 'nameUp':
default:
$request->sort = 'nameUp';
$criteria->addAscendingOrderByColumn('name');
}
// Page results
$this->pager = new QubitPager('QubitPhysicalObject');
$this->pager->setCriteria($criteria);
$this->pager->setMaxPerPage($request->limit);
$this->pager->setPage($request->page);
}
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 getTaxonomyTerms($taxonomyId, $options = array())
{
$criteria = new Criteria();
$criteria->add(QubitTerm::TAXONOMY_ID, $taxonomyId);
// Only include top-level terms if option is set
if (isset($options['level']) && $options['level'] == 'top') {
$criteria->add(QubitTerm::PARENT_ID, QubitTerm::ROOT_ID);
}
// Sort alphabetically
$criteria->addAscendingOrderByColumn('name');
// Do source culture fallback
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitTerm');
return QubitTerm::get($criteria);
}
public function execute($request)
{
if (!isset($request->limit)) {
$request->limit = sfConfig::get('app_hits_per_page');
}
$criteria = new Criteria();
$criteria->add(QubitActor::PARENT_ID, QubitActor::ROOT_ID);
// Add criteria to exclude actors that are users or repository objects
$criteria = QubitActor::addGetOnlyActorsCriteria($criteria);
$fallbackTable = 'QubitActor';
switch ($request->sort) {
case 'nameDown':
$criteria->addDescendingOrderByColumn('authorized_form_of_name');
break;
case 'nameUp':
$criteria->addAscendingOrderByColumn('authorized_form_of_name');
break;
case 'typeDown':
$fallbackTable = 'QubitTerm';
$criteria->addJoin(QubitActor::ENTITY_TYPE_ID, QubitTerm::ID, Criteria::LEFT_JOIN);
$criteria->addDescendingOrderByColumn('name');
break;
case 'typeUp':
$fallbackTable = 'QubitTerm';
$criteria->addJoin(QubitActor::ENTITY_TYPE_ID, QubitTerm::ID, Criteria::LEFT_JOIN);
$criteria->addAscendingOrderByColumn('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, $fallbackTable);
// Page results
$this->pager = new QubitPager('QubitActor');
$this->pager->setCriteria($criteria);
$this->pager->setMaxPerPage($request->limit);
$this->pager->setPage($request->page);
}
public function execute($request)
{
if (!isset($request->limit)) {
$request->limit = sfConfig::get('app_hits_per_page');
}
$criteria = new Criteria();
$criteria->add(QubitAclGroup::ID, QubitAclGroup::ROOT_ID, Criteria::NOT_EQUAL);
$criteria->addAscendingOrderByColumn('name');
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitAclGroup');
// Page results
$this->pager = new QubitPager('QubitAclGroup');
$this->pager->setCriteria($criteria);
$this->pager->setMaxPerPage($request->limit);
$this->pager->setPage($request->page);
$this->groups = $this->pager->getResults();
}
/**
* Execute digitalobject list action
*
* @param sfWebRequest $request
*/
public function execute($request)
{
// Build funky join query to get a count of top level digital objects
// for each media type (term)
$criteria = new Criteria();
$criteria->add(QubitTerm::TAXONOMY_ID, QubitTaxonomy::MEDIA_TYPE_ID);
$criteria->addJoin(QubitTerm::ID, QubitDigitalObject::MEDIA_TYPE_ID, Criteria::LEFT_JOIN);
$criteria->addAsColumn('hits', 'COUNT(' . QubitDigitalObject::ID . ')');
$criteria->addGroupByColumn(QubitTerm::ID);
// Add I18n fallback
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitTerm');
$criteria->addAscendingOrderByColumn('name');
// Filter drafts
$criteria->addJoin(QubitDigitalObject::INFORMATION_OBJECT_ID, QubitInformationObject::ID);
$criteria = QubitAcl::addFilterDraftsCriteria($criteria);
$this->terms = QubitTerm::get($criteria);
}
public function execute($request)
{
if (!isset($request->limit)) {
$request->limit = sfConfig::get('app_hits_per_page');
}
$criteria = new Criteria();
// Show only editable taxonomies
$criteria = QubitTaxonomy::addEditableTaxonomyCriteria($criteria);
// Do source culture fallback
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitTaxonomy');
$criteria->addAscendingOrderByColumn('name');
// Page results
$this->pager = new QubitPager('QubitTaxonomy');
$this->pager->setCriteria($criteria);
$this->pager->setMaxPerPage($request->limit);
$this->pager->setPage($request->page);
$this->taxonomies = $this->pager->getResults();
}
public function execute($request)
{
if (!isset($request->limit)) {
$request->limit = sfConfig::get('app_hits_per_page');
}
$this->resource = $this->getRoute()->resource;
$criteria = new Criteria();
$criteria->add(QubitObjectTermRelation::TERM_ID, $this->resource->id);
$criteria->addJoin(QubitObjectTermRelation::OBJECT_ID, QubitInformationObject::ID);
$criteria = QubitAcl::addFilterDraftsCriteria($criteria);
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitInformationObject');
$criteria->addAscendingOrderByColumn('title');
$this->pager = new QubitPager('QubitInformationObject');
$this->pager->setCriteria($criteria);
$this->pager->setMaxPerPage($request->limit);
$this->pager->setPage($request->page);
$this->informationObjects = $this->pager->getResults();
}
public function execute($request)
{
if (!isset($request->limit)) {
$request->limit = sfConfig::get('app_hits_per_page');
}
$this->resource = $this->getRoute()->resource;
$criteria = new Criteria();
$criteria->add(QubitTerm::TAXONOMY_ID, $this->resource->id);
$criteria->add(QubitTerm::PARENT_ID, QubitTerm::ROOT_ID);
// Do source culture fallback
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitTerm');
$criteria->addAscendingOrderByColumn('name');
// Page results
$this->pager = new QubitPager('QubitTerm');
$this->pager->setCriteria($criteria);
$this->pager->setMaxPerPage($request->limit);
$this->pager->setPage($request->page);
$this->terms = $this->pager->getResults();
}
public function execute($request)
{
if (!isset($request->limit)) {
$request->limit = sfConfig::get('app_hits_per_page');
}
$criteria = new Criteria();
// Do source culture fallback
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitActor');
// don't let ananymous users see records with draft status
if (!$this->getUser()->isAuthenticated()) {
$criteria->addJoin(QubitRepository::ID, QubitStatus::OBJECT_ID, Criteria::LEFT_JOIN);
$ct1 = $criteria->getNewCriterion(QubitStatus::TYPE_ID, QubitTerm::STATUS_TYPE_PUBLICATION_ID);
$ct2 = $criteria->getNewCriterion(QubitStatus::STATUS_ID, QubitTerm::PUBLICATION_STATUS_PUBLISHED_ID);
$ct1->addAnd($ct2);
$criteria->addAnd($ct1);
}
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);
}
}
// Page results
$this->pager = new QubitPager('QubitRepository');
$this->pager->setCriteria($criteria);
$this->pager->setMaxPerPage($request->limit);
$this->pager->setPage($request->page);
}
public function execute($request)
{
if (!isset($request->limit)) {
$request->limit = sfConfig::get('app_hits_per_page');
}
// HACK Use id deliberately, vs. slug, because "Subjects" and "Places"
// menus still use id
$this->resource = QubitTaxonomy::getById($request->id);
if (!isset($this->resource)) {
$this->forward404();
}
$criteria = new Criteria();
$criteria->add(QubitTerm::TAXONOMY_ID, $this->resource->id);
$criteria->addJoin(QubitTerm::ID, QubitObjectTermRelation::TERM_ID);
$criteria->addJoin(QubitObjectTermRelation::OBJECT_ID, QubitInformationObject::ID);
$criteria = QubitAcl::addFilterDraftsCriteria($criteria);
// Do culture fallback
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitTerm');
$criteria->addGroupByColumn(QubitTerm::ID);
$criteria->addAsColumn('hits', 'COUNT(' . QubitTerm::ID . ')');
switch ($request->sort) {
case 'hitsDown':
$criteria->addDescendingOrderByColumn('hits');
break;
case 'hitsUp':
$criteria->addAscendingOrderByColumn('hits');
break;
case 'termNameDown':
$criteria->addDescendingOrderByColumn('name');
break;
case 'termNameUp':
default:
$criteria->addAscendingOrderByColumn('name');
break;
}
$this->pager = new QubitPager('QubitTerm');
$this->pager->setCriteria($criteria);
$this->pager->setMaxPerPage($request->limit);
$this->pager->setPage($request->page);
$this->terms = $this->pager->getResults();
}
protected function addField($name)
{
switch ($name) {
case 'searchFields':
break;
case 'repository':
// Get list of repositories
$criteria = new Criteria();
// Do source culture fallback
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitActor');
$criteria->addAscendingOrderByColumn('authorized_form_of_name');
$choices = array('' => '');
foreach (QubitRepository::get($criteria) as $repository) {
$choices[$repository->id] = $repository;
}
$this->form->setValidator($name, new sfValidatorChoice(array('choices' => array_keys($choices))));
$this->form->setWidget($name, new sfWidgetFormSelect(array('choices' => $choices), array('style' => 'min-width: 50%; width: auto')));
break;
case 'mediatype':
// Get list of media types
$criteria = new Criteria();
$criteria->add(QubitTerm::TAXONOMY_ID, QubitTaxonomy::MATERIAL_TYPE_ID);
// Do source culture fallback
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitTerm');
$criteria->addAscendingOrderByColumn('name');
$choices = array('' => '');
foreach (QubitTerm::get($criteria) as $mediatype) {
$choices[$mediatype->id] = $mediatype;
}
$this->form->setValidator($name, new sfValidatorChoice(array('choices' => array_keys($choices))));
$this->form->setWidget($name, new sfWidgetFormSelect(array('choices' => $choices), array('style' => 'width: auto')));
break;
case 'hasDigitalObject':
$choices = array('' => '', 'true' => 'Yes', 'false' => 'No');
$this->form->setValidator($name, new sfValidatorChoice(array('choices' => array_keys($choices))));
$this->form->setWidget($name, new sfWidgetFormSelect(array('choices' => $choices), array('style' => 'width: auto')));
break;
}
}
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();
// Do source culture fallback
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitActor');
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);
}
}
// Page results
$this->pager = new QubitPager('QubitDonor');
$this->pager->setCriteria($criteria);
$this->pager->setMaxPerPage($request->limit);
$this->pager->setPage($request->page);
}
public function execute($request)
{
if (!isset($request->limit)) {
$request->limit = sfConfig::get('app_hits_per_page');
}
$this->resource = $request->getAttribute('sf_route')->resource;
if (!isset($this->resource)) {
return sfView::NONE;
}
$criteria = new Criteria();
$criteria->addJoin(QubitInformationObject::ID, QubitObject::ID);
$criteria->add(QubitInformationObject::REPOSITORY_ID, $this->resource->id);
$criteria->addAscendingOrderByColumn('title');
// Sort holdings alphabetically (w/ fallback)
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitInformationObject');
// Filter draft descriptions
$criteria = QubitAcl::addFilterDraftsCriteria($criteria);
// Paginate holdings list
$this->pager = new QubitPager('QubitInformationObject');
$this->pager->setCriteria($criteria);
$this->pager->setMaxPerPage($request->limit);
$this->pager->setPage($request->page);
$this->holdings = $this->pager->getResults();
}
public function execute($request)
{
$criteria = new Criteria();
$criteria->addJoin(QubitActor::ID, QubitActorI18n::ID);
$criteria->add(QubitActorI18n::AUTHORIZED_FORM_OF_NAME, "{$request->query}%", Criteria::LIKE);
$criteria->addAscendingOrderByColumn('authorized_form_of_name');
$criteria->setDistinct();
$criteria->setLimit(sfConfig::get('app_hits_per_page', 10));
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitActor');
// Filter "denied" repositories if list for repository autocomplete on
// information object form
if (isset($request->aclAction)) {
$repositoryList = array();
$repositoryAccess = QubitAcl::getRepositoryAccess($request->aclAction);
// If all repositories are denied, no response
if (1 == count($repositoryAccess) && QubitAcl::DENY == $repositoryAccess[0]['access']) {
return sfView::NONE;
} else {
while ($repo = array_shift($repositoryAccess)) {
if ('*' != $repo['id']) {
$repositoryList[] = $repo['id'];
} else {
if (QubitAcl::DENY == $repo['access']) {
// Require repositories to be specifically allowed (all others
// prohibited)
$criteria->add(QubitRepository::ID, $repositoryList + array('null'), Criteria::IN);
} else {
// Prohibit specified repositories (all others allowed)
$criteria->add(QubitRepository::ID, $repositoryList, Criteria::NOT_IN);
}
}
}
}
}
$this->repositories = QubitRepository::get($criteria);
}
public function doSearch()
{
$criteria = new Criteria();
$this->sort = $this->request->getParameter('sort', 'updatedDown');
// This join seems to be necessary to avoid cross joining the local table
// with the QubitObject table
$criteria->addJoin(constant($this->className . '::ID'), QubitObject::ID);
switch ($this->form->getValue('className')) {
case 'QubitActor':
$nameColumn = 'authorized_form_of_name';
$this->nameColumnDisplay = 'Name';
$criteria = QubitActor::addGetOnlyActorsCriteria($criteria);
$criteria->add(QubitActor::PARENT_ID, null, Criteria::ISNOTNULL);
break;
case 'QubitFunction':
$nameColumn = 'authorized_form_of_name';
$this->nameColumnDisplay = 'Name';
break;
case 'QubitRepository':
$nameColumn = 'authorized_form_of_name';
$this->nameColumnDisplay = 'Name';
$criteria = QubitRepository::addGetOnlyRepositoryCriteria($criteria);
break;
case 'QubitTerm':
$nameColumn = 'name';
$this->nameColumnDisplay = 'Name';
$criteria->add(QubitTerm::PARENT_ID, null, Criteria::ISNOTNULL);
break;
// Default: information object
// Default: information object
default:
$nameColumn = 'title';
$this->nameColumnDisplay = 'Title';
$criteria->add(QubitInformationObject::PARENT_ID, null, Criteria::ISNOTNULL);
}
if ('QubitInformationObject' == $this->className && 'all' != $this->form->getValue('publicationStatus')) {
$criteria->addJoin(QubitObject::ID, QubitStatus::OBJECT_ID);
$criteria->add(QubitStatus::STATUS_ID, $this->form->getValue('publicationStatus'));
}
// End date at midnight
if (null != $this->form->getValue('dateEnd')) {
$dateEnd = $this->form->getValue('dateEnd') . ' 24:00:00';
}
// Add date criteria
switch ($dateOf = $this->form->getValue('dateOf')) {
case 'CREATED_AT':
case 'UPDATED_AT':
if (null !== $this->form->getValue('dateStart')) {
$criteria->addAnd(constant('QubitObject::' . $dateOf), $this->form->getValue('dateStart'), Criteria::GREATER_EQUAL);
}
if (isset($dateEnd)) {
$criteria->addAnd(constant('QubitObject::' . $dateOf), $dateEnd, Criteria::LESS_EQUAL);
}
break;
default:
if (null !== $this->form->getValue('dateStart')) {
$c1 = $criteria->getNewCriterion(QubitObject::CREATED_AT, $this->form->getValue('dateStart'), Criteria::GREATER_EQUAL);
$c2 = $criteria->getNewCriterion(QubitObject::UPDATED_AT, $this->form->getValue('dateStart'), Criteria::GREATER_EQUAL);
$c1->addOr($c2);
$criteria->addAnd($c1);
}
if (isset($dateEnd)) {
$c3 = $criteria->getNewCriterion(QubitObject::CREATED_AT, $dateEnd, Criteria::LESS_EQUAL);
$c4 = $criteria->getNewCriterion(QubitObject::UPDATED_AT, $dateEnd, Criteria::LESS_EQUAL);
$c3->addOr($c4);
$criteria->addAnd($c3);
}
}
// Add sort criteria
switch ($this->sort) {
case 'nameDown':
$criteria->addDescendingOrderByColumn($nameColumn);
break;
case 'nameUp':
$criteria->addAscendingOrderByColumn($nameColumn);
break;
case 'updatedUp':
$criteria->addAscendingOrderByColumn(QubitObject::UPDATED_AT);
break;
case 'updatedDown':
default:
$criteria->addDescendingOrderByColumn(QubitObject::UPDATED_AT);
}
// Add fallback criteria for name
if ('nameDown' == $this->sort || 'nameUp' == $this->sort) {
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, $this->form->getValue('className'));
}
// Page results
$this->pager = new QubitPager($this->className);
$this->pager->setCriteria($criteria);
$this->pager->setMaxPerPage($this->form->getValue('limit'));
$this->pager->setPage($this->request->getParameter('page', 1));
}
private static function getFullTree($currentNode, $limit)
{
$tree = array();
// Get direct ancestors
$ancestors = $currentNode->getAncestors()->orderBy('lft');
foreach ($ancestors as $ancestor) {
$tree[$ancestor->id] = $ancestor;
}
// Get siblings (with limit) - but don't show sibling collection roots
$totalSiblings = 0;
$criteria = new Criteria();
$criteria->add(QubitTerm::PARENT_ID, $currentNode->parentId);
if (QubitTerm::ROOT_ID == $currentNode->parentId) {
$criteria->add(QubitTerm::TAXONOMY_ID, $currentNode->taxonomyId);
}
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitTerm');
$criteria->addAscendingOrderByColumn('name');
if (0 < $limit) {
$criteria->setLimit($limit);
}
foreach (QubitTerm::get($criteria) as $item) {
// Keep track of position of $currentNode in array
if ($item === $currentNode) {
$curIndex = count($tree);
}
$tree[] = $item;
}
$totalSiblings = intval(BasePeer::doCount($criteria->setLimit(0))->fetchColumn(0));
// Add current object to $tree if it wasn't added as a sibling
if (!isset($curIndex)) {
if ($totalSiblings >= $limit) {
// replace last sibling with current object
array_splice($tree, -1, 1, array($currentNode));
} else {
$tree[] = $currentNode;
}
$curIndex = count($tree) - 1;
}
if ($totalSiblings > $limit) {
$tree[] = array('total' => $totalSiblings, 'limit' => $limit, 'parentId' => $currentNode->parentId);
}
// Get children (with limit)
$totalChildren = 0;
$criteria = new Criteria();
$criteria->add(QubitTerm::PARENT_ID, $currentNode->id);
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitTerm');
$criteria->addAscendingOrderByColumn('name');
if (0 < $limit) {
$criteria->setLimit($limit);
}
if (0 < count($children = QubitTerm::get($criteria))) {
foreach ($children as $item) {
$childs[] = $item;
}
$totalChildren = intval(BasePeer::doCount($criteria->setLimit(0))->fetchColumn(0));
if ($totalChildren > $limit) {
$childs[] = array('total' => $totalChildren, 'limit' => $limit, 'parentId' => $currentNode->id);
}
// Insert children right AFTER current info object in array
if ($curIndex == count($tree) - 1) {
$tree = array_merge($tree, $childs);
} else {
array_splice($tree, $curIndex + 1, 0, $childs);
}
}
return $tree;
}
public static function addTreeViewSortCriteria($criteria)
{
switch (sfConfig::get('app_sort_treeview_informationobject')) {
case 'identifierTitle':
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitInformationObject');
$criteria->addAscendingOrderByColumn('identifier');
$criteria->addAscendingOrderByColumn('title');
break;
case 'title':
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitInformationObject');
$criteria->addAscendingOrderByColumn('title');
break;
default:
$criteria->addAscendingOrderByColumn(self::LFT);
}
return $criteria;
}
public static function getAllExceptUsers($options = array())
{
//returns all Actor objects except those that are
//also an instance of the User class
$criteria = new Criteria();
$criteria->add(QubitObject::CLASS_NAME, 'QubitActor');
// sort by name
$criteria->addAscendingOrderByColumn('authorized_form_of_name');
// Do fallback
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitActor', $options);
return QubitActor::get($criteria);
}
