function xoonips_admin_maintenance_item_delete_item($iid)
{
$factory = new XooNIpsLogicFactory();
$remove_item_logic =& $factory->create('removeItem');
$vars = array($_SESSION['XNPSID'], $iid, 'item_id');
$response = new XooNIpsResponse();
$remove_item_logic->execute($vars, $response);
return $response->getResult();
}
function doAction()
{
$factory =& XooNIpsLogicFactory::getInstance();
$logic =& $factory->create($this->_get_logic_name());
if (!is_object($logic)) {
$this->_response->setResult(false);
$this->_error->add(XNPERR_SERVER_ERROR, "can't create a logic:" . $this->_get_logic_name());
return;
}
$logic->execute($this->_params, $this->_response);
}
/**
* load and execute xoonips logic.
*
* @param[in] XooNIpsXmlRpcRequest $request
* @param[out] XooNIpsXmlRpcResponse $response
* result of logic(success/fault, response, error)
*/
function execute(&$request, &$response)
{
// load logic instance
$factory =& XooNIpsLogicFactory::getInstance();
$logic =& $factory->create($request->getMethodName());
if (!is_object($logic)) {
$response->setResult(false);
$error =& $response->getError();
$logic = $request->getMethodName();
$error->add(XNPERR_SERVER_ERROR, "can't create a logic of {$logic}");
return;
}
// execute logic
$params =& $request->getParams();
$xoonips_response = new XooNIpsResponse();
if (count($params) < 2) {
$response->setResult(false);
$error =& $response->getError();
$error->add(XNPERR_MISSING_PARAM);
return false;
} else {
if (count($params) > 2) {
$response->setResult(false);
$error =& $response->getError();
$error->add(XNPERR_EXTRA_PARAM);
return false;
}
}
$vars = array();
$vars[0] = $params[0];
$vars[1] = $params[1];
$logic->execute($vars, $xoonips_response);
//
$response->setResult($xoonips_response->getResult());
$response->setError($xoonips_response->getError());
if ($xoonips_response->getResult()) {
$result = array();
foreach ($xoonips_response->getSuccess() as $index_compo) {
$result[] = $this->convertIndexObjectToIndexStructure($index_compo, $response);
}
$response->setSuccess($result);
}
}
/**
* load and execute xoonips logic.
*
* @param[in] XooNIpsXmlRpcRequest $request
* @param[out] XooNIpsXmlRpcResponse $response
* result of logic(success/fault, response, error)
*/
function execute(&$request, &$response)
{
// load logic instance
$factory =& XooNIpsLogicFactory::getInstance();
$logic =& $factory->create($request->getMethodName());
if (!is_object($logic)) {
$response->setResult(false);
$error =& $response->getError();
$logic = $request->getMethodName();
$error->add(XNPERR_SERVER_ERROR, "can't create a logic of {$logic}");
return;
}
// execute logic
$params =& $request->getParams();
$xoonips_response = new XooNIpsResponse();
if (count($params) < 3) {
$response->setResult(false);
$error =& $response->getError();
$error->add(XNPERR_MISSING_PARAM);
return false;
} else {
if (count($params) > 3) {
$response->setResult(false);
$error =& $response->getError();
$error->add(XNPERR_EXTRA_PARAM);
return false;
}
}
$vars = array();
$vars[0] = $params[0];
$unicode =& xoonips_getutility('unicode');
$vars[1] = array();
foreach ($params[1] as $key => $val) {
$vars[1][$key] = $unicode->decode_utf8($val, xoonips_get_server_charset(), 'h');
}
$vars[2] = $params[2];
$logic->execute($vars, $xoonips_response);
//
$response->setResult($xoonips_response->getResult());
$response->setError($xoonips_response->getError());
$response->setSuccess($xoonips_response->getSuccess());
}
/**
* load and execute xoonips logic. see [xoonips:00025]
*
* @param[in] XooNIpsXmlRpcRequest $request
* @param[out] XooNIpsXmlRpcResponse $response result of logic(success/fault, response, error)
*/
function execute(&$request, &$response)
{
// load logic instance
$factory =& XooNIpsLogicFactory::getInstance();
$logic =& $factory->create($request->getMethodName());
if (!is_object($logic)) {
$response->setResult(false);
$error =& $response->getError();
$logic = $request->getMethodName();
$error->add(XNPERR_SERVER_ERROR, "can't create a logic of {$logic}");
return;
}
// execute logic
$vars =& $request->getParams();
$xoonips_response = new XooNIpsResponse();
$logic->execute($vars, $xoonips_response);
//
$response->setResult($xoonips_response->getResult());
$response->setError($xoonips_response->getError());
$response->setSuccess($xoonips_response->getSuccess());
}
/**
*
* @param[in] XooNIpsXmlRpcRequest $request
* @param[out] XooNIpsXmlRpcResponse $response
* result of logic(success/fault, response, error)
*/
function execute(&$request, &$response)
{
// load logic instance
$factory =& XooNIpsLogicFactory::getInstance();
$logic =& $factory->create($request->getMethodName());
if (!is_object($logic)) {
$response->setResult(false);
$error =& $response->getError();
$logic = $request->getMethodName();
$error->add(XNPERR_SERVER_ERROR, "can't create a logic of {$logic}");
return;
}
//
$params =& $request->getParams();
$vars = array();
if (count($params) < 4) {
$response->setResult(false);
$error =& $response->getError();
$error->add(XNPERR_MISSING_PARAM);
return false;
} else {
if (count($params) > 4) {
$response->setResult(false);
$error =& $response->getError();
$error->add(XNPERR_EXTRA_PARAM);
return false;
}
}
//
// parameter 1(sessionid)
$vars[0] = $params[0];
//
// transform array to object
// parameter 2(item structure) to XooNIpsItemCompo object
// using XooNIpsTransformCompo<itemtype>
$item_type_id = intval($params[1]['itemtype']);
$itemtype_handler =& xoonips_getormhandler('xoonips', 'item_type');
$itemtype =& $itemtype_handler->get($item_type_id);
if (!$itemtype) {
$response->setResult(false);
$response->setError(new XooNIpsError(XNPERR_INVALID_PARAM, "item type of {$item_type_id} is not found"));
return false;
}
//
$factory =& XooNIpsXmlRpcTransformCompoFactory::getInstance();
$trans =& $factory->create($itemtype->get('name'));
$missing = array();
if (!$trans->isFilledRequired($params[1], $missing)) {
$response->setResult(false);
$err =& $response->getError();
foreach ($missing as $m) {
$err->add(XNPERR_INCOMPLETE_PARAM, $m);
}
return false;
}
// check mulitple of each variable
$fields = array();
if (!$trans->checkMultipleFields($params[1], $fields)) {
$response->setResult(false);
$err =& $response->getError();
foreach ($fields as $m) {
$err->add(XNPERR_INCOMPLETE_PARAM, $m);
}
return false;
}
// check fields
if (!$trans->checkFields($params[1], $response->getError())) {
// some fields have invalid value
return false;
}
// transform array to item object, and set it to $vars.
$vars[1] = $trans->getObject($params[1]);
// transform array to object
// parameter 3(file structure) to XooNIpsFile object
// using XooNIpsTransformFile
// and write file data to temporary file
$factory =& XooNIpsXmlRpcTransformFactory::getInstance();
$trans =& $factory->create('xoonips', 'file');
if (is_array($params[2])) {
$vars[2] = array();
foreach ($params[2] as $p) {
$fileobj = $trans->getObject($p);
if (!$fileobj) {
$response->setResult(false);
$response->setError(new XooNIpsError(XNPERR_INVALID_PARAM, "can't get file from XML"));
return false;
}
$tmpfile = tempnam("/tmp", "FOO");
$h = fopen($tmpfile, "wb");
if ($h) {
$len = fwrite($h, $p['data']);
fclose($h);
}
if (!$h || $len != strlen($p['data'])) {
$response->setResult(false);
$response->setError(new XooNIpsError(XNPERR_SERVER_ERROR, "can't write to file {$tmpfile}"));
return false;
}
$fileobj->setFilepath($tmpfile);
$vars[2][] = $fileobj;
}
}
// parameter 4(array of remove file id)
$vars[3] = $params[3];
// execute logic
$xoonips_response = new XooNIpsResponse();
$logic->execute($vars, $xoonips_response);
//
$response->setResult($xoonips_response->getResult());
$response->setError($xoonips_response->getError());
$response->setSuccess($xoonips_response->getSuccess());
}
function xoonips_delete_item($item_id)
{
$params = array(session_id(), $item_id, 'item_id');
$response = new XooNIpsResponse();
$factory =& XooNIpsLogicFactory::getInstance();
$logic =& $factory->create('removeItem');
$logic->execute($params, $response);
if ($response->getResult()) {
redirect_header(XOOPS_URL . '/', 3, "Succeed");
} else {
redirect_header(XOOPS_URL . '/', 3, "ERROR");
}
}
/**
*
* @param[in] XooNIpsXmlRpcRequest $request
* @param[out] XooNIpsXmlRpcResponse $response result of logic(success/fault, response, error)
*/
function execute(&$request, &$response)
{
// load logic instance
$factory =& XooNIpsLogicFactory::getInstance();
$logic =& $factory->create($request->getMethodName());
if (!is_object($logic)) {
$response->setResult(false);
$error =& $response->getError();
$logic = $request->getMethodName();
$error->add(XNPERR_SERVER_ERROR, "can't create a logic of {$logic}");
return;
}
//
$params =& $request->getParams();
$vars = array();
if (count($params) < 2) {
$response->setResult(false);
$error =& $response->getError();
$error->add(XNPERR_MISSING_PARAM);
return false;
} else {
if (count($params) > 2) {
$response->setResult(false);
$error =& $response->getError();
$error->add(XNPERR_EXTRA_PARAM);
return false;
}
}
//
// parameter 1(sessionid)
$vars[0] = $params[0];
//
// transform array to object
// parameter 2(item structure) to XooNIpsItemCompo object
// using XooNIpsTransformCompo<itemtype>
$item_type_id = intval($params[1]['itemtype']);
$itemtype_handler =& xoonips_getormhandler('xoonips', 'item_type');
$itemtype =& $itemtype_handler->get($item_type_id);
if (!$itemtype) {
$response->setResult(false);
$response->setError(new XooNIpsError(XNPERR_INVALID_PARAM, "item type of {$item_type_id} is not found"));
return false;
}
//
$factory =& XooNIpsXmlRpcTransformCompoFactory::getInstance();
$trans =& $factory->create($itemtype->get('name'));
$missing = array();
if (!$trans->isFilledRequired($params[1], $missing)) {
$response->setResult(false);
$err =& $response->getError();
foreach ($missing as $m) {
$err->add(XNPERR_INCOMPLETE_PARAM, $m);
}
return false;
}
// check mulitple of each variable
$fields = array();
if (!$trans->checkMultipleFields($params[1], $fields)) {
$response->setResult(false);
$err =& $response->getError();
foreach ($fields as $m) {
$err->add(XNPERR_INCOMPLETE_PARAM, $m);
}
return false;
}
// check fields
if (!$trans->checkFields($params[1], $response->getError())) {
// some fields have invalid value
return false;
}
// transform array to item object, and set it to $vars.
$vars[1] = $trans->getObject($params[1]);
// execute logic
$xoonips_response = new XooNIpsResponse();
$logic->execute($vars, $xoonips_response);
//
$response->setResult($xoonips_response->getResult());
$response->setError($xoonips_response->getError());
$response->setSuccess($xoonips_response->getSuccess());
}
/**
*
* @param[in] XooNIpsXmlRpcRequest $request
* @param[out] XooNIpsXmlRpcResponse $response result of logic(success/fault, response, error)
*/
function execute(&$request, &$response)
{
$error =& $response->getError();
// load logic instance
$factory =& XooNIpsLogicFactory::getInstance();
$logic =& $factory->create($request->getMethodName());
if (!is_object($logic)) {
$response->setResult(false);
$error =& $response->getError();
$logic = $request->getMethodName();
$error->add(XNPERR_SERVER_ERROR, "can't create a logic of {$logic}");
return false;
}
//
$params =& $request->getParams();
$vars = array();
if (count($params) < 5) {
$response->setResult(false);
$error->add(XNPERR_MISSING_PARAM);
return false;
} else {
if (count($params) > 5) {
$response->setResult(false);
$error->add(XNPERR_EXTRA_PARAM);
return false;
}
}
//
// parameter 1(sessionid)
$vars[0] = $params[0];
//
// parameter 2(itemid)
$unicode =& xoonips_getutility('unicode');
$vars[1] = $unicode->decode_utf8($params[1], xoonips_get_server_charset(), 'h');
//
// parameter 3(id_type)
$vars[2] = $params[2];
//
// parameter 4(fieldName)
$vars[3] = $params[3];
//
//
// transform array to object
// parameter 5(file structure) to XooNIpsFile object
// using XooNIpsTransformFile
// and write file data to temporary file
$factory =& XooNIpsXmlRpcTransformFactory::getInstance();
$trans =& $factory->create('xoonips', 'file');
$fileobj = $trans->getObject($params[4]);
if (!$fileobj) {
$response->setResult(false);
$error->add(XNPERR_INVALID_PARAM, 'can not get file from parameter #5');
return false;
}
$tmpfile = tempnam("/tmp", "FOO");
$h = fopen($tmpfile, "wb");
if ($h) {
$len = fwrite($h, $params[4]['data']);
fclose($h);
}
if (!$h || $len != strlen($params[4]['data'])) {
$response->setResult(false);
$error->add(XNPERR_SERVER_ERROR, "can't write to file {$tmpfile}");
return false;
}
$fileobj->setFilepath($tmpfile);
$vars[4] = $fileobj;
// execute logic
$xoonips_response = new XooNIpsResponse();
$logic->execute($vars, $xoonips_response);
//
$response->setResult($xoonips_response->getResult());
$response->setError($xoonips_response->getError());
$response->setSuccess($xoonips_response->getSuccess());
}
function doAction()
{
global $xoopsUser;
include_once dirname(dirname(__DIR__)) . '/include/imexport.php';
$filetype = $this->_formdata->getValue('post', 'filetype', 's', false);
$remotefile = $this->_formdata->getValue('post', 'remotefile', 's', false);
$zipfile = $this->_formdata->getFile('zipfile', false);
if ($filetype == 'localfile' && (empty($zipfile['name']) || $zipfile['size'] == 0) || $filetype == 'remotefile' && empty($remotefile)) {
redirect_header('import.php?action=default', 3, _MD_XOONIPS_IMPORT_FILE_NOT_SPECIFIED);
exit;
}
//set path of import file
if ($filetype == 'localfile') {
$uploadfile = $this->_move_upload_file($zipfile['tmp_name']);
} else {
$uploadfile = $remotefile;
}
if (!file_exists($uploadfile)) {
redirect_header('import.php?action=default', 3, _MD_XOONIPS_IMPORT_FILE_NOT_FOUND);
exit;
}
if ($this->_is_index_xml_in_import_file($uploadfile)) {
$this->_read_index_tree($uploadfile, $this->_formdata->getValue('post', 'error_check_only', 's', false), $this->_get_xoonips_checked_index_ids($this->_formdata->getValue('post', 'xoonipsCheckedXID', 's', false)));
return;
}
$this->_params[] = $uploadfile;
$this->_params[] = $this->_get_xoonips_checked_index_ids($this->_formdata->getValue('post', 'xoonipsCheckedXID', 's', false));
$factory =& XooNIpsLogicFactory::getInstance();
$logic =& $factory->create('importReadFile');
$logic->execute($this->_params, $this->_response);
@unlink($uploadfile);
$success =& $this->_response->getSuccess();
if (!$this->_response->getResult() || $this->_import_item_have_errors($success['import_items'])) {
$this->_view_params['result'] = false;
$success = $this->_response->getSuccess();
$this->_view_params['import_items'] = $success['import_items'];
$this->_view_params['uname'] = $xoopsUser->getVar('uname');
$this->_view_params['filename'] = $filetype == 'localfile' ? $zipfile['name'] : $remotefile;
$this->_view_params['errors'] = array();
foreach ($success['import_items'] as $item) {
foreach (array_unique($item->getErrorCodes()) as $code) {
$this->_view_params['errors'][] = array('code' => $code, 'extra' => $item->getPseudoId());
}
}
$this->_view_name = "import_log";
return;
}
$handler =& xoonips_gethandler('xoonips', 'import_item');
$handler->setCertifyAutoOption($success['import_items'], !is_null($this->_formdata->getValue('post', 'certify_auto', 's', false)));
$collection = new XooNIpsImportItemCollection();
//
// check conflict below
//
$this->_params = array($success['import_items']);
$factory =& XooNIpsLogicFactory::getInstance();
$logic =& $factory->create('importCheckConflict');
$logic->execute($this->_params, $this->_response);
$success =& $this->_response->getSuccess();
$this->_set_errors_to_import_items($success['import_items']);
if (!is_null($this->_formdata->getValue('post', 'error_check_only', 's', false)) || $this->_import_item_have_errors($success['import_items']) || !$this->_response->getResult()) {
$this->_view_params['result'] = $this->_response->getResult() && !$this->_import_item_have_errors($success['import_items']);
$this->_view_params['uname'] = $xoopsUser->getVar('uname');
$this->_view_params['filename'] = $filetype == 'localfile' ? $zipfile['name'] : $remotefile;
$this->_view_params['import_items'] = $success['import_items'];
$this->_view_params['errors'] = array();
foreach ($success['import_items'] as $item) {
foreach (array_unique($item->getErrorCodes()) as $code) {
$this->_view_params['errors'][] = array('code' => $code, 'extra' => $item->getPseudoId());
}
}
$this->_view_name = 'import_log';
return;
} else {
if ($success['is_conflict']) {
$this->_view_params['import_items'] = $success['import_items'];
$this->_view_name = 'import_conflict';
} else {
// importCheckImport logic
$this->_params = array($success['import_items'], $xoopsUser->getVar('uid'), false);
$factory =& XooNIpsLogicFactory::getInstance();
$logic =& $factory->create('importCheckImport');
$logic->execute($this->_params, $this->_response);
$success =& $this->_response->getSuccess();
if ($success['private_item_number_limit_over'] || $success['private_item_storage_limit_over']) {
if ($success['private_item_number_limit_over']) {
$collection->addError('Private item number limit exceeds.');
} else {
if ($success['private_item_storage_limit_over']) {
$collection->addError('Too large file of item to import.');
}
}
$this->_view_params['result'] = false;
$this->_view_params['uname'] = $xoopsUser->getVar('uname');
$this->_view_params['filename'] = $filetype == 'localfile' ? $zipfile['name'] : $remotefile;
$this->_view_params['errors'] = array();
$this->_view_params['import_items'] = $success['import_items'];
foreach ($success['import_items'] as $item) {
foreach (array_unique($item->getErrorCodes()) as $code) {
$this->_view_params['errors'][] = array('code' => $code, 'extra' => $item->getPseudoId());
}
}
foreach ($collection->getErrors() as $err) {
$this->_view_params['errors'][] = array('extra' => $err);
}
$this->_view_name = 'import_log';
} else {
$this->_view_params['ticket_html'] = $GLOBALS['xoopsGTicket']->getTicketHtml(__LINE__, 600, 'import');
$this->_view_name = 'import_confirm';
}
}
}
foreach ($success['import_items'] as $i) {
$collection->addItem($i);
}
$collection->setLoggingOption(!is_null($this->_formdata->getValue('post', 'logging', 's', false)));
if ($filetype == 'localfile') {
$collection->setImportFileName($zipfile['name']);
} else {
$collection->setImportFileName($remotefile);
}
$sess_handler =& xoonips_getormhandler('xoonips', 'session');
$sess =& $sess_handler->get(session_id());
$session = unserialize($sess->get('sess_data'));
$session['xoonips_import_items'] = base64_encode(gzcompress(serialize($collection)));
$sess->set('sess_data', serialize($session));
$sess_handler->insert($sess);
}
/**
* execute searchItem
*
* @param[in] $vars[0] session ID
* @param[in] $vars[1] query string
* @param[in] $vars[2] offset of the first row to return (The offset of the initial row is 0)
* @param[in] $vars[3] maximum number of rows to return (0:all rows)
* @param[in] $vars[4] sort key('title'|'ext_id'|'last_modified_date'|'registration_date'|'creation_date')
* @param[in] $vars[5] sort order('asc'|'desc')
* @param[out] $response->result true:success, false:failed
* @param[out] $response->error error information
* @param[out] $response->success['count'] number of matched item
* @param[out] $response->success[n] search result
* @param[out] $response->success[n]['id'] item id of matched item
* @param[out] $response->success[n]['matchfor'] bit flag represents what part of item matched
*/
function execute(&$vars, &$response)
{
// parameter check
$error =& $response->getError();
if (count($vars) > 6) {
$error->add(XNPERR_EXTRA_PARAM);
}
if (count($vars) < 6) {
$error->add(XNPERR_MISSING_PARAM);
}
//
if (isset($vars[0]) && strlen($vars[0]) > 32) {
$error->add(XNPERR_INVALID_PARAM, 'too long parameter 1');
}
$ar = explode(':', $vars[1]);
if (count($ar) < 2 || !in_array($ar[0], array('index', 'keyword'))) {
$error->add(XNPERR_INVALID_PARAM, 'bad query parameter 2');
}
if (!is_int($vars[2]) && !ctype_digit($vars[2])) {
$error->add(XNPERR_INVALID_PARAM, 'not integer parameter 2');
}
if (!is_int($vars[3]) && !ctype_digit($vars[3])) {
$error->add(XNPERR_INVALID_PARAM, 'not integer parameter 3');
}
if (!in_array($vars[4], array('title', 'ext_id', 'last_modified_date', 'registration_date', 'creation_date'))) {
$error->add(XNPERR_INVALID_PARAM, 'unknown sort key parameter 4');
}
if (!in_array($vars[5], array('asc', 'desc'))) {
$error->add(XNPERR_INVALID_PARAM, 'unknown sort order parameter 5');
}
//
if ($error->get(0)) {
// return if parameter error
$response->setResult(false);
return;
} else {
$sessionid = $vars[0];
$query = $vars[1];
$start = $vars[2];
$limit = $vars[3];
$sortkey = $vars[4];
$ascdesc = $vars[5];
}
list($result, $uid, $session) = $this->restoreSession($sessionid);
if (!$result) {
$response->setResult(false);
$error->add(XNPERR_INVALID_SESSION);
return false;
}
$response->setResult(false);
// convert ($start, $limit, $sortkey, $ascdesc) to ($criteria, $join_sort_table)
$criteria = new CriteriaCompo();
$criteria->setOrder($ascdesc);
$criteria->setStart($start);
$criteria->setLimit($limit);
switch ($sortkey) {
case 'title':
$join_sort_table = 'xoonips_item_title';
$criteria->add(new Criteria('title_id', 0));
$criteria->setSort('title');
break;
case 'ext_id':
$join_sort_table = false;
$criteria->setSort('doi');
break;
case 'last_modified_date':
$join_sort_table = false;
$criteria->setSort('last_update_date');
break;
case 'registration_date':
$join_sort_table = false;
$criteria->setSort('creation_date');
break;
case 'creation_date':
$join_sort_table = false;
$criteria->setSort(array('publication_year', 'publication_month', 'publication_mday'));
break;
default:
$error->add(XNPERR_INVALID_PARAM, 'unknown sort key parameter 4');
$response->setResult(false);
return false;
break;
}
// get valid item_type_ids -> $criteria
$factory =& XooNIpsLogicFactory::getInstance();
$logic =& $factory->create("getItemTypes");
$vars = array($sessionid);
$logic->execute($vars, $response);
if ($response->getResult() == false) {
return false;
}
$itemtypes = $response->getSuccess();
if (count($itemtypes) == 0) {
// no itemtype found. return empty array.
$ar = array();
$response->setSuccess($ar);
$response->setResult(true);
return true;
}
$itemtype_ids = array();
foreach ($itemtypes as $itemtype) {
$itemtype_ids[] = $itemtype->get('item_type_id');
}
$criteria->add(new Criteria('item_type_id', '(' . implode(',', $itemtype_ids) . ')', 'IN'));
if (substr($query, 0, 6) == 'index:') {
// index id -> search_cache_items
$index_id = substr($query, 6);
if (!ctype_digit($index_id)) {
$error->add(XNPERR_INVALID_PARAM, "bad index id(index_id={$index_id})");
$response->setResult(false);
return false;
}
$criteria->add(new Criteria('index_id', $index_id));
$index_handler =& xoonips_getormhandler('xoonips', 'index');
$index = $index_handler->get($index_id);
if (false == $index) {
$error->add(XNPERR_NOT_FOUND, "index not found(index_id={$index_id})");
$response->setResult(false);
return false;
}
if (!$index_handler->getPerm($index_id, $uid, 'read')) {
$error->add(XNPERR_ACCESS_FORBIDDEN, "forbidden(index_id={$index_id})");
$response->setResult(false);
return false;
}
// xoonips_index_item_link <- $join(xoonips_item_basic) <- $join2($join_sort_table)
$index_item_link_handler =& xoonips_getormhandler('xoonips', 'index_item_link');
$join = new XooNIpsJoinCriteria('xoonips_item_basic', 'item_id', 'item_id');
if ($join_sort_table) {
$join2 = new XooNIpsJoinCriteria($join_sort_table, 'item_id', 'item_id');
$join->cascade($join2);
}
$index_item_links =& $index_item_link_handler->getObjects($criteria, false, '', false, $join);
$item_compo_handler =& xoonips_getormcompohandler('xoonips', 'item');
$search_cache_item_handler =& xoonips_getormhandler('xoonips', 'search_cache_item');
$search_cache_items = array();
foreach ($index_item_links as $index_item_link) {
if (!$item_compo_handler->getPerm($index_item_link->get('item_id'), $uid, 'read')) {
continue;
}
// no read permission
$search_cache_item = $search_cache_item_handler->create();
$search_cache_item->set('item_id', $index_item_link->get('item_id'));
$search_cache_item->set('matchfor_index', 1);
$search_cache_item->set('matchfor_item', 0);
$search_cache_item->set('matchfor_file', 0);
$search_cache_items[] = $search_cache_item;
}
$response->setSuccess($search_cache_items);
$response->setResult(true);
return true;
} else {
if (substr($query, 0, 8) == 'keyword:') {
$search_cache_id = $this->getSearchCacheIdByQuery($query);
$search_cache_handler =& xoonips_getormhandler('xoonips', 'search_cache');
$eventlog_handler =& xoonips_getormhandler('xoonips', 'event_log');
if ($search_cache_id) {
$search_cache = $search_cache_handler->get($search_cache_id);
if ($search_cache === false) {
// maybe invalidated.
$search_cache_id = false;
} else {
$c = new CriteriaCompo();
$event_type_ids = array(ETID_INSERT_ITEM, ETID_UPDATE_ITEM, ETID_DELETE_ITEM, ETID_DELETE_GROUP, ETID_INSERT_GROUP_MEMBER, ETID_DELETE_GROUP_MEMBER, ETID_DELETE_INDEX, ETID_CERTIFY_ITEM, ETID_REJECT_ITEM, ETID_TRANSFER_ITEM);
$c->add(new Criteria('event_type_id', '(' . implode(',', $event_type_ids) . ')', 'in'));
$c->add(new Criteria("timestamp - unix_timestamp('" . $search_cache->get('timestamp') . "')", 0, '>='));
$c->setSort('timestamp');
$c->setOrder('desc');
$c->setLimit(1);
$event_logs =& $eventlog_handler->getObjects($c);
if (false === $event_logs) {
$response->setResult(false);
$error->add(XNPERR_SERVER_ERROR, "cannot get event logs");
return false;
} else {
if (!empty($event_logs)) {
$search_cache_id = false;
// delete old search results from search cache
$c = new CriteriaCompo(new Criteria('sess_id', $sessionid));
$c->add(new Criteria('unix_timestamp(timestamp)', $event_logs[0]->get('timestamp'), '<'));
$search_caches =& $search_cache_handler->getObjects($c);
if (false === $search_caches) {
$response->setResult(false);
$error->add(XNPERR_SERVER_ERROR, "cannot get search cache ids");
return false;
}
$search_cache_item_handler =& xoonips_getormhandler('xoonips', 'search_cache_item');
foreach ($search_caches as $search_cache) {
$id = $search_cache->get('search_cache_id');
$this->deleteSearchCache($id);
$search_cache_handler->delete($search_cache);
$search_cache_item_handler->deleteAll(new Criteria('search_cache_id', $id));
}
}
}
}
}
if (!$search_cache_id) {
$search_cache = $search_cache_handler->create();
$search_cache->setVar('sess_id', $sessionid, true);
if (!$search_cache_handler->insert($search_cache)) {
$response->setResult(false);
$error->add(XNPERR_SERVER_ERROR, "cannot create search_cache_id");
return false;
}
$search_cache_id = $search_cache->get('search_cache_id');
$keyword = substr($query, 8);
$this->keywordSearch($error, $search_cache_id, $uid, $keyword);
if (!$eventlog_handler->recordQuickSearchEvent('all', $keyword)) {
$error->add(XNPERR_SERVER_ERROR, "cannot insert event");
$response->setResult(false);
return false;
}
}
//
// access permission: ol_public && ( is_moderator || certify_state=certified) || ol_group_only && gid=gulink.gid && ( is_admin || certify_state==certified) || ol_private && uid=uid // how to reuse?
// -> criteria
$c = new CriteriaCompo();
$c->add(new Criteria('open_level', OL_PUBLIC));
$member_handler =& xoonips_gethandler('xoonips', 'member');
if (!$member_handler->isModerator($uid)) {
$c->add(new Criteria('certify_state', CERTIFIED));
}
$groups_users_link_handler =& xoonips_getormhandler('xoonips', 'groups_users_link');
$links =& $groups_users_link_handler->getObjects(new Criteria('uid', $uid));
foreach ($links as $link) {
$c->add(new Criteria('open_level', OL_GROUP_ONLY), 'OR');
$c->add(new Criteria('gid', $link->get('gid')));
if (!$link->get('is_admin')) {
$c->add(new Criteria('certify_state', CERTIFIED));
}
}
$c->add(new Criteria('open_level', OL_PRIVATE), 'OR');
$c->add(new Criteria('tx.uid', $uid));
$criteria->add($c);
$criteria->add(new Criteria('search_cache_id', $search_cache_id));
$criteria->setGroupby('search_cache_item_id');
// join:
// xoonips_search_cache_item <- $join(xoonips_index_item_link)
// <- $join2(xoonips_index)
// <- $join3(xoonips_item_basic)
// <- $join4($join_sort_table)
$join = new XooNIpsJoinCriteria('xoonips_index_item_link', 'item_id', 'item_id', 'LEFT', 'txil');
$join2 = new XooNIpsJoinCriteria('xoonips_index', 'index_id', 'index_id', 'LEFT', 'tx');
$join3 = new XooNIpsJoinCriteria('xoonips_item_basic', 'item_id', 'item_id');
$join4 = new XooNIpsJoinCriteria($join_sort_table, 'item_id', 'item_id');
$join->cascade($join2, 'txil', true);
$join->cascade($join3, 'xoonips_search_cache_item');
if ($join_sort_table) {
$join->cascade($join4, 'xoonips_search_cache_item');
}
$search_cache_item_handler =& xoonips_getormhandler('xoonips', 'search_cache_item');
$search_cache_items =& $search_cache_item_handler->getObjects($criteria, false, '', false, $join);
if ($search_cache_items === false) {
$error->add(XNPERR_INVALID_PARAM, 'cannot get searched item');
$response->setResult(false);
return false;
}
$this->putSearchCache($query, $search_cache_id);
$response->setSuccess($search_cache_items);
$response->setResult(true);
return true;
} else {
$error->add(XNPERR_INVALID_PARAM, "query must begin with index: or keyword:");
}
}
if ($error->get()) {
$response->setResult(false);
return false;
}
}
