public function execute($request)
{
if (!isset($request->limit)) {
$request->limit = sfConfig::get('app_hits_per_page');
}
$this->resource = $this->getRoute()->resource;
// Check that this isn't the root
if (!isset($this->resource->parent)) {
$this->forward404();
}
$search = new QubitSearch();
$query = new Zend_Search_Lucene_Search_Query_Boolean();
$query->addSubquery(new Zend_Search_Lucene_Search_Query_Term(new Zend_Search_Lucene_Index_Term($this->resource->id, 'parentId')), true);
if (isset($request->query)) {
$query = $request->query;
}
$query = QubitAcl::searchFilterByRepository($query, 'read');
$query = QubitAcl::searchFilterDrafts($query);
$this->pager = new QubitArrayPager();
$this->pager->hits = $search->getEngine()->getIndex()->find($query);
$this->pager->setMaxPerPage($request->limit);
$this->pager->setPage($request->page);
$ids = array();
foreach ($this->pager->getResults() as $hit) {
$ids[] = $hit->getDocument()->id;
}
$criteria = new Criteria();
$criteria->add(QubitInformationObject::ID, $ids, Criteria::IN);
$this->informationObjects = QubitInformationObject::get($criteria);
}
public function delete($connection = null)
{
parent::delete($connection);
if ($this->getObject() instanceof QubitInformationObject) {
QubitSearch::updateInformationObject($this->getObject());
}
}
public function execute($request)
{
if (!isset($request->limit)) {
$request->limit = sfConfig::get('app_hits_per_page');
}
if (isset($request->subquery)) {
try {
// Parse query string
$query = QubitSearch::getInstance()->parse($request->subquery);
} catch (Exception $e) {
$this->error = $e->getMessage();
return;
}
} else {
$this->redirect(array('module' => 'actor', 'action' => 'browse'));
}
$query->addSubquery(QubitSearch::getInstance()->addTerm('QubitActor', 'className'), true);
$query = QubitAcl::searchFilterByResource($query, QubitActor::getById(QubitActor::ROOT_ID));
$this->pager = new QubitArrayPager();
try {
$this->pager->hits = QubitSearch::getInstance()->getEngine()->getIndex()->find($query);
} catch (Exception $e) {
$this->error = $e->getMessage();
return;
}
$this->pager->setMaxPerPage($request->limit);
$this->pager->setPage($request->page);
$ids = array();
foreach ($this->pager->getResults() as $hit) {
$ids[] = $hit->getDocument()->id;
}
$criteria = new Criteria();
$criteria->add(QubitActor::ID, $ids, Criteria::IN);
$this->actors = QubitActor::get($criteria);
}
/**
* Display a paginated hitlist of information objects (top-level only)
*
* @param sfRequest $request
*/
public function execute($request)
{
if (!isset($request->limit)) {
$request->limit = sfConfig::get('app_hits_per_page');
}
$this->resource = QubitInformationObject::getById(QubitInformationObject::ROOT_ID);
if (isset($this->getRoute()->resource)) {
$this->resource = $this->getRoute()->resource;
}
$query = QubitSearch::getInstance()->addTerm($this->resource->id, 'parentId');
if (isset($request->query)) {
$query = $request->query;
}
$query = QubitAcl::searchFilterByRepository($query, 'read');
$query = QubitAcl::searchFilterDrafts($query);
$this->pager = new QubitArrayPager();
$this->pager->hits = QubitSearch::getInstance()->getEngine()->getIndex()->find($query);
$this->pager->setMaxPerPage($request->limit);
$this->pager->setPage($request->page);
$ids = array();
foreach ($this->pager->getResults() as $hit) {
$ids[] = $hit->getDocument()->id;
}
$criteria = new Criteria();
$criteria->add(QubitInformationObject::ID, $ids, Criteria::IN);
$this->informationObjects = QubitInformationObject::get($criteria);
}
public function delete($connection = null)
{
parent::delete($connection);
if (isset($this->informationObject)) {
QubitSearch::updateInformationObject($this->getInformationObject());
}
}
public function execute($request)
{
// Use existing symfony task
$cacheClear = new sfCacheClearTask(sfContext::getInstance()->getEventDispatcher(), new sfFormatter());
$cacheClear->run();
// Clear the search index
QubitSearch::getInstance()->getEngine()->erase();
QubitSearch::getInstance()->optimize();
$this->redirect(array('module' => 'sfInstallPlugin', 'action' => 'finishInstall'));
}
public function filterQuery($query)
{
// Limit search to current culture and info. objects
$query->addSubquery(QubitSearch::getInstance()->addTerm('QubitInformationObject', 'className'), true);
$query->addSubquery(QubitSearch::getInstance()->addTerm($this->context->user->getCulture(), 'culture'), true);
$query = QubitAcl::searchFilterByRepository($query, 'read');
$query = QubitAcl::searchFilterDrafts($query);
// Limit to a repository if in context
if (isset($this->getRoute()->resource) && $this->getRoute()->resource instanceof QubitRepository) {
$query->addSubquery(QubitSearch::getInstance()->addTerm($this->getRoute()->resource->id, 'repositoryId'), true);
$this->title .= $this->context->i18n->__(' in %1%', array('%1%' => $this->getRoute()->resource->authorizedFormOfName));
}
return $query;
}
public function execute($request)
{
parent::execute($request);
$this->addFields();
$this->title = $this->context->i18n->__('Global search/replace');
if ($request->isMethod('post')) {
// Make sure we have required information for search/replace
if (empty($request->pattern) || empty($request->replacement)) {
$this->error = $this->context->i18n->__('Both source and replacement fields are required.');
return;
} else {
if (!isset($request->confirm)) {
$this->title = $this->context->i18n->__('Are you sure you want to replace "%1%" with "%2%" in %3%?', array('%1%' => $request->pattern, '%2%' => $request->replacement, '%3%' => sfInflector::humanize(sfInflector::underscore($request->column))));
return;
}
}
// Process replacement on each IO
// NB: could this be made faster by reading a batch of IDs?
foreach ($this->pager->hits as $hit) {
$io = QubitInformationObject::getById($hit->getDocument()->id);
if (isset($request->allowRegex)) {
$pattern = '/' . strtr($request->pattern, array('/' => '\\/')) . '/';
if (!isset($request->caseSensitive)) {
$pattern .= 'i';
}
$replacement = strtr($request->replacement, array('/' => '\\/'));
$replaced = preg_replace($pattern, $replacement, $io->__get($request->column));
} elseif (isset($request->caseSensitive)) {
$replaced = str_replace($request->pattern, $request->replacement, $io->__get($request->column));
} else {
$replaced = str_ireplace($request->pattern, $request->replacement, $io->__get($request->column));
}
$io->__set($request->column, $replaced);
$io->save();
}
// force refresh of index to keep sync
QubitSearch::getInstance()->optimize();
// When complete, redirect to GSR home
$this->redirect(array('module' => 'search', 'action' => 'globalReplace'));
}
}
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');
}
if (isset($request->subquery)) {
try {
// Parse query string
$query = QubitSearch::getInstance()->parse($request->subquery);
} catch (Exception $e) {
$this->error = $e->getMessage();
return;
}
} else {
$this->redirect(array('module' => 'donor', 'action' => 'browse'));
}
$query->addSubquery(QubitSearch::getInstance()->addTerm('QubitDonor', 'className'), true);
$this->pager = new QubitArrayPager();
try {
$this->pager->hits = QubitSearch::getInstance()->getEngine()->getIndex()->find($query);
} catch (Exception $e) {
$this->error = $e->getMessage();
return;
}
$this->pager->setMaxPerPage($request->limit);
$this->pager->setPage($request->page);
$ids = array();
foreach ($this->pager->getResults() as $hit) {
$ids[] = $hit->getDocument()->id;
}
$criteria = new Criteria();
$criteria->add(QubitDonor::ID, $ids, Criteria::IN);
$this->donors = QubitDonor::get($criteria);
}
public function filterQuery($query)
{
// limit to a repository if selected
if (!empty($this->request->repository)) {
$query->addSubquery(QubitSearch::getInstance()->addTerm($this->request->repository, 'repositoryId'), true);
$this->queryTerms[] = array('term' => $this->getContext()->i18n->__('Repository') . ': ' . QubitRepository::getById($this->request->repository)->__toString(), 'operator' => 'and');
}
// digital object filters
if ('true' == $this->request->hasDigitalObject) {
$query->addSubquery(QubitSearch::getInstance()->addTerm('true', 'hasDigitalObject'), true);
$this->queryTerms[] = array('term' => $this->getContext()->i18n->__('Digital object is available'), 'operator' => 'and');
} else {
if ('false' == $this->request->hasDigitalObject) {
$query->addSubquery(QubitSearch::getInstance()->addTerm('false', 'hasDigitalObject'), true);
$this->queryTerms[] = array('term' => $this->getContext()->i18n->__('No digital object is available'), 'operator' => 'and');
}
}
if (!empty($this->request->mediatype)) {
$query->addSubquery(QubitSearch::getInstance()->addTerm($this->request->mediatype, 'do_mediaTypeId'), true);
$this->queryTerms[] = array('term' => 'mediatype: ' . QubitTerm::getById($this->request->mediatyp)->__toString(), 'operator' => 'and');
}
$query = parent::filterQuery($query);
return $query;
}
/**
* Override base delete method to unlink related digital assets (thumbnail
* and file)
*
* @param sfConnection A database connection
*/
public function delete($connection = null)
{
$criteria = new Criteria();
$criteria->add(QubitDigitalObject::PARENT_ID, $this->id);
$children = QubitDigitalObject::get($criteria);
// Delete children
foreach ($children as $child) {
foreach (QubitRelation::getBySubjectOrObjectId($this->id) as $item) {
$item->delete();
}
$child->delete();
}
// Delete digital asset
if (file_exists($this->getAbsolutePath())) {
unlink($this->getAbsolutePath());
}
// Prune asset directory, if empty
self::pruneEmptyDirs(sfConfig::get('sf_web_dir') . $this->path);
foreach (QubitRelation::getBySubjectOrObjectId($this->id) as $item) {
$item->delete();
}
// Update search index before deleting self
if (!empty($this->informationObjectId)) {
QubitSearch::updateInformationObject($this->getInformationObject());
}
// Delete self
parent::delete($connection);
}
protected function execute($arguments = array(), $options = array())
{
$timer = new QubitTimer();
// overall timing
$context = sfContext::createInstance($this->configuration);
if (empty($arguments['folder']) || !file_exists($arguments['folder'])) {
throw new sfException('You must specify a valid import folder or file');
}
// Set indexing preference
if ($options['noindex']) {
QubitSearch::getInstance()->disabled = true;
} else {
QubitSearch::getInstance()->getEngine()->enableBatchMode();
}
if (is_dir($arguments['folder'])) {
// Recurse into the import folder
$files = $this->dir_tree(rtrim($arguments['folder'], '/'));
} else {
$files = array($arguments['folder']);
}
// TODO: Add some colour
$this->log("Importing " . count($files) . " files from " . $arguments['folder'] . " (indexing is " . ($options['noindex'] ? "DISABLED" : "ENABLED") . ") ...\n");
$count = 0;
$total = count($files);
foreach ($files as $file) {
$start = microtime(true);
// Choose import type based on file extension, eg. csv, xml
if ('csv' == pathinfo($file, PATHINFO_EXTENSION)) {
$importer = new QubitCsvImport();
$importer->import($file, $options);
} elseif ('xml' == pathinfo($file, PATHINFO_EXTENSION)) {
$importer = new QubitXmlImport();
$importer->import($file, array('strictXmlParsing' => false));
} else {
// Move on to the next file
continue;
}
// Try to free up memory
unset($importer);
$count++;
$split = microtime(true) - $start;
// Store details if output is specified
if ($options['output']) {
$rows[] = array($count, $split, memory_get_usage());
}
if ($options['v']) {
$this->log(basename($file) . " imported (" . round($split, 2) . " s) (" . $count . "/" . $total . ")");
}
}
// Create/open output file if specified
if ($options['output']) {
$fh = fopen($options['output'], 'w+');
foreach ($rows as $row) {
fputcsv($fh, $row);
}
fputcsv($fh, array('', $timer->elapsed(), memory_get_peak_usage()));
fclose($fh);
}
// Optimize index if enabled
if (!$options['noindex']) {
QubitSearch::getInstance()->getEngine()->optimize();
}
$this->log("\nSuccessfully imported " . $count . " XML/CSV files in " . $timer->elapsed() . " s. " . memory_get_peak_usage() . " bytes used.");
}
/**
* Delete an existing document from the index
*
* @param integer $id object identifier
* @param string $language ISO-639-1 code
* @return void
*/
public static function deleteByIdLanguage($id, $language)
{
// have to use another search object to perform the querying
$querier = new QubitSearch();
$query = new Zend_Search_Lucene_Search_Query_MultiTerm();
$query->addTerm(new Zend_Search_Lucene_Index_Term($id, 'id'), true);
$query->addTerm(new Zend_Search_Lucene_Index_Term($language, 'culture'), true);
foreach ($querier->getEngine()->getIndex()->find($query) as $hit) {
self::getInstance()->getEngine()->getIndex()->delete($hit->id);
}
}
/**
* Additional actions to take on delete
*
*/
public function delete($connection = null)
{
$this->deletePhysicalObjectRelations();
// Delete subject relations
$criteria = new Criteria();
$criteria = $this->addrelationsRelatedBysubjectIdCriteria($criteria);
if ($subjectRelations = QubitRelation::get($criteria)) {
foreach ($subjectRelations as $subjectRelation) {
$subjectRelation->delete();
}
}
// Delete object relations
$criteria = new Criteria();
$criteria = $this->addrelationsRelatedByobjectIdCriteria($criteria);
if ($objectRelations = QubitRelation::get($criteria)) {
foreach ($objectRelations as $objectRelation) {
$objectRelation->delete();
}
}
parent::delete($connection);
QubitSearch::deleteInformationObject($this);
}
protected function updateLinkedInfoObjects()
{
foreach ($this->resource->objectTermRelations as $item) {
if ($item->object instanceof QubitInformationObject) {
QubitSearch::updateInformationObject($item->object);
}
}
return $this;
}
public function execute($request)
{
// Default items per page
if (!isset($request->limit)) {
$request->limit = sfConfig::get('app_hits_per_page');
}
$this->form = new sfForm();
$this->resource = $this->getRoute()->resource;
// Check that the object exists and that it is not the root
if (!isset($this->resource) || !isset($this->resource->parent)) {
$this->forward404();
}
// Check authorization
if (!QubitAcl::check($this->resource, 'update')) {
QubitAcl::forwardUnauthorized();
}
// "parent" form field
$this->form->setValidator('parent', new sfValidatorString(array('required' => true)));
$this->form->setWidget('parent', new sfWidgetFormInputHidden());
// Root is default parent
if ($this->resource instanceof QubitInformationObject) {
$this->form->bind($request->getGetParameters() + array('parent' => $this->context->routing->generate(null, array(QubitInformationObject::getById(QubitInformationObject::ROOT_ID), 'module' => 'informationobject'))));
} else {
if ($this->resource instanceof QubitTerm) {
$this->form->bind($request->getGetParameters() + array('parent' => $this->context->routing->generate(null, array(QubitTerm::getById(QubitTerm::ROOT_ID), 'module' => 'term'))));
}
}
if ($request->isMethod('post')) {
$this->form->bind($request->getPostParameters());
if ($this->form->isValid()) {
$params = $this->context->routing->parse(Qubit::pathInfo($this->form->parent->getValue()));
// In term treeview, root node links (href) to taxonomy, but it represents the term root object
if ($this->resource instanceof QubitTerm && QubitObject::getById($params['_sf_route']->resource->id) instanceof QubitTaxonomy) {
$this->resource->parentId = QubitTerm::ROOT_ID;
} else {
$this->resource->parentId = $params['_sf_route']->resource->id;
}
$this->resource->save();
if ($request->isXmlHttpRequest()) {
return $this->renderText('');
} else {
if ($this->resource instanceof QubitInformationObject) {
$this->redirect(array($this->resource, 'module' => 'informationobject'));
} else {
if ($this->resource instanceof QubitTerm) {
$this->redirect(array($this->resource, 'module' => 'term'));
}
}
}
}
}
$params = $this->context->routing->parse(Qubit::pathInfo($this->form->parent->getValue()));
$this->parent = QubitObject::getById($params['_sf_route']->resource->id);
$query = QubitSearch::getInstance()->addTerm($this->parent->slug, 'parent');
if (isset($request->query)) {
$query = $request->query;
}
$this->pager = new QubitArrayPager();
$this->pager->hits = QubitSearch::getInstance()->getEngine()->getIndex()->find($query);
$this->pager->setMaxPerPage($request->limit);
$this->pager->setPage($request->page);
$ids = array();
foreach ($this->pager->getResults() as $hit) {
$ids[] = $hit->getDocument()->id;
}
$criteria = new Criteria();
$criteria->add(QubitObject::ID, $ids, Criteria::IN);
$this->results = QubitObject::get($criteria);
}
public function delete($connection = null)
{
QubitSearch::deleteById($this->id);
return parent::delete($connection);
}
/**
* Filter search query by resource specific ACL
*
* @param $query
* @param mixed $root - root object for list
* @return query
*/
public static function searchFilterByResource($query, $root)
{
$user = sfContext::getInstance()->user;
$permissions = self::getUserPermissionsByAction($user, get_class($root), 'read');
// Build access control list
$grants = 0;
if (0 < count($permissions)) {
foreach ($permissions as $permission) {
if (!isset($resourceAccess[$permission->objectId])) {
$resourceAccess[$permission->objectId] = self::isAllowed($user, $permission->objectId, 'read');
if ($resourceAccess[$permission->objectId]) {
$grants++;
}
}
}
}
// If no grants then user can't see anything
if (0 == $grants) {
self::forwardUnauthorized();
} else {
if (!self::isAllowed($user, $root->id, 'read')) {
$allows = array_keys($resourceAccess, true, true);
while ($resourceId = array_shift($allows)) {
$query->addSubquery(QubitSearch::getInstance()->addTerm($resourceId, 'id'), true);
}
} else {
$bans = array_keys($resourceAccess, false, true);
while ($resourceId = array_shift($bans)) {
$query->addSubquery(QubitSearch::getInstance()->addTerm($resourceId, 'id'), false);
}
}
}
return $query;
}
public function execute($request)
{
$this->timer = new QubitTimer();
$file = $request->getFiles('file');
// if we got here without a file upload, go to file selection
if (!isset($file)) {
$this->redirect(array('module' => 'object', 'action' => 'importSelect'));
}
// set indexing preference
if ($request->getParameter('noindex')) {
QubitSearch::getInstance()->disabled = true;
} else {
QubitSearch::getInstance()->getEngine()->enableBatchMode();
}
try {
// choose import type based on file extension, eg. csv, xml
if ('csv' == pathinfo($file['name'], PATHINFO_EXTENSION)) {
$importer = new QubitCsvImport();
$importer->import($file['tmp_name'], array('schema' => $request->getParameter('schema')));
} elseif ('xml' == pathinfo($file['name'], PATHINFO_EXTENSION)) {
$importer = new QubitXmlImport();
$importer->import($file['tmp_name'], array('strictXmlParsing' => false));
} elseif ('zip' == pathinfo($file['name'], PATHINFO_EXTENSION) && class_exists('ZipArchive')) {
$zipFolder = $file['tmp_name'] . '-zip';
if (!file_exists($zipFolder)) {
mkdir($zipFolder, 0755);
}
// extract the zip archive into the temporary folder
// TODO: need some error handling here
$zip = new ZipArchive();
$zip->open($file['tmp_name']);
$zip->extractTo($zipFolder);
$zip->close();
$files = $this->dir_tree($zipFolder);
// this code is from lib/importBulkTask.class.php
foreach ($files as $import_file) {
// try to free up memory
unset($importer);
// choose import type based on file extension, eg. csv, xml
if ('csv' == pathinfo($import_file, PATHINFO_EXTENSION)) {
$importer = new QubitCsvImport();
$importer->import($import_file, array('schema'));
} elseif ('xml' == pathinfo($import_file, PATHINFO_EXTENSION)) {
$importer = new QubitXmlImport();
$importer->import($import_file, array('strictXmlParsing' => false));
} else {
// move on to the next file
continue;
}
}
} else {
$this->context->user->setFlash('error', $this->context->i18n->__('Unable to import selected file'));
$this->redirect(array('module' => 'object', 'action' => 'importSelect'));
}
} catch (sfException $e) {
$this->context->user->setFlash('error', $e->getMessage());
$this->redirect(array('module' => 'object', 'action' => 'importSelect'));
}
// optimize index if enabled
if (!$request->getParameter('noindex')) {
QubitSearch::getInstance()->getEngine()->optimize();
}
$this->errors = $importer->getErrors();
$this->rootObject = $importer->getRootObject();
$this->objectType = strtr(get_class($this->rootObject), array('Qubit' => ''));
}
