public static function call(OkapiRequest $request) { # Read the parameters. $acode = $request->get_parameter('acode'); if ($acode === null) { throw new ParamMissing('acode'); } if (strstr($acode, '|')) { throw new InvalidParam('acode', "Only a single A-code must be supplied."); } $langpref = $request->get_parameter('langpref'); if (!$langpref) { $langpref = "en"; } $fields = $request->get_parameter('fields'); if (!$fields) { $fields = "name"; } $forward_compatible = $request->get_parameter('forward_compatible'); if (!$forward_compatible) { $forward_compatible = "true"; } # Pass them all to the attributes method. $params = array('acodes' => $acode, 'langpref' => $langpref, 'fields' => $fields, 'forward_compatible' => $forward_compatible); $results = OkapiServiceRunner::call('services/attrs/attributes', new OkapiInternalRequest($request->consumer, $request->token, $params)); $result = $results[$acode]; if ($result === null) { /* Note, this can happen only when $forward_compatible is false. */ throw new InvalidParam('acode', "Unknown A-code."); } return Okapi::formatted_response($request, $result); }
public static function call(OkapiRequest $request) { $search_assistant = new SearchAssistant($request); $search_assistant->prepare_common_search_params(); $result = $search_assistant->get_common_search_result(); return Okapi::formatted_response($request, $result); }
static function call(OkapiRequest $request) { require_once 'log_images_common.inc.php'; list($image_uuid, $log_internal_id) = LogImagesCommon::validate_image_uuid($request); $image_uuid_escaped = Db::escape_string($image_uuid); Db::execute('start transaction'); $image_row = Db::select_row("\n select id, node, url, local\n from pictures\n where uuid = '" . $image_uuid_escaped . "'\n "); Db::execute("\n delete from pictures where uuid = '" . $image_uuid_escaped . "'\n "); # Remember that OCPL picture sequence numbers are always 1, and # OCDE sequence numbers may have gaps. So we do not need to adjust # any numbers after deleting from table 'pictures'. if (Settings::get('OC_BRANCH') == 'oc.de') { # OCDE does all the housekeeping by triggers } else { Db::execute("\n INSERT INTO removed_objects (\n localID, uuid, type, removed_date, node\n )\n VALUES (\n " . $image_row['id'] . "\n '" . $image_uuid_escaped . "',\n 6,\n NOW(),\n " . $image_row['node'] . "\n )\n "); # This will also update cache_logs.okapi_syncbase, so that replication # can output the updated log entry with one image less. For OCDE # that's done by DB trigges. Db::execute("\n update cache_logs\n set\n picturescount = greatest(0, picturescount - 1),\n last_modified = NOW()\n where id = '" . Db::escape_string($log_internal_id) . "'\n "); } Db::execute('commit'); if ($image_row['local']) { $filename = basename($image_row['url']); unlink(Settings::get('IMAGES_DIR') . '/' . $filename); } $result = array('success' => true); return Okapi::formatted_response($request, $result); }
public static function call(OkapiRequest $request) { # User is already verified (via OAuth), but we need to verify the # cache code (check if it exists). We will simply call a geocache method # on it - this will also throw a proper exception if it doesn't exist. $cache_code = $request->get_parameter('cache_code'); if ($cache_code == null) { throw new ParamMissing('cache_code'); } $geocache = OkapiServiceRunner::call('services/caches/geocache', new OkapiInternalRequest($request->consumer, $request->token, array('cache_code' => $cache_code, 'fields' => 'internal_id'))); # watched if ($tmp = $request->get_parameter('watched')) { if (!in_array($tmp, array('true', 'false', 'unchanged'))) { throw new InvalidParam('watched', $tmp); } if ($tmp == 'true') { Db::execute("\n insert ignore into cache_watches (cache_id, user_id)\n values (\n '" . Db::escape_string($geocache['internal_id']) . "',\n '" . Db::escape_string($request->token->user_id) . "'\n );\n "); } elseif ($tmp == 'false') { Db::execute("\n delete from cache_watches\n where\n cache_id = '" . Db::escape_string($geocache['internal_id']) . "'\n and user_id = '" . Db::escape_string($request->token->user_id) . "';\n "); } } # ignored if ($tmp = $request->get_parameter('ignored')) { if (!in_array($tmp, array('true', 'false', 'unchanged'))) { throw new InvalidParam('ignored', $tmp); } if ($tmp == 'true') { Db::execute("\n insert ignore into cache_ignore (cache_id, user_id)\n values (\n '" . Db::escape_string($geocache['internal_id']) . "',\n '" . Db::escape_string($request->token->user_id) . "'\n );\n "); } elseif ($tmp == 'false') { Db::execute("\n delete from cache_ignore\n where\n cache_id = '" . Db::escape_string($geocache['internal_id']) . "'\n and user_id = '" . Db::escape_string($request->token->user_id) . "'\n "); } } $result = array('success' => true); return Okapi::formatted_response($request, $result); }
public static function call(OkapiRequest $request) { $issue_id = $request->get_parameter('issue_id'); if (!$issue_id) { throw new ParamMissing('issue_id'); } if (!preg_match("/^[0-9]+\$/", $issue_id) || strlen($issue_id) > 6) { throw new InvalidParam('issue_id'); } $cache_key = "apiref/issue#" . $issue_id; $result = Cache::get($cache_key); if ($result == null) { # Download the number of comments from GitHub Issue Tracker. try { $extra_headers = array(); $extra_headers[] = "Accept: application/vnd.github.v3.html+json"; $extra_headers[] = "User-Agent: https://github.com/opencaching/okapi/"; if (Settings::get('GITHUB_ACCESS_TOKEN')) { $extra_headers[] = "Authorization: token " . Settings::get('GITHUB_ACCESS_TOKEN'); } $opts = array('http' => array('method' => "GET", 'timeout' => 2.0, 'header' => implode("\r\n", $extra_headers))); $context = stream_context_create($opts); $json = file_get_contents("https://api.github.com/repos/opencaching/okapi/issues/{$issue_id}", false, $context); } catch (ErrorException $e) { throw new BadRequest("Sorry, we could not retrieve issue stats from the GitHub site. " . "This is probably due to a temporary connection problem. Try again later or contact " . "us if this seems permanent."); } $doc = json_decode($json, true); $result = array('id' => $issue_id + 0, 'last_updated' => $doc['updated_at'], 'title' => $doc['title'], 'url' => $doc['html_url'], 'comment_count' => $doc['comments']); # On one hand, we want newly added comments to show up quickly. # On the other, we don't want OKAPI to spam GitHub with queries. # So it's difficult to choose the best timeout for this. Cache::set($cache_key, $result, 3600); } return Okapi::formatted_response($request, $result); }
public static function call(OkapiRequest $request) { $result = array(); $result['site_url'] = Settings::get('SITE_URL'); $result['okapi_base_url'] = $result['site_url'] . "okapi/"; $result['site_name'] = Okapi::get_normalized_site_name(); $result['okapi_revision'] = Okapi::$revision; return Okapi::formatted_response($request, $result); }
public static function call(OkapiRequest $request) { $cachekey = "apisrv/stats"; $result = Cache::get($cachekey); if (!$result) { $result = array('cache_count' => 0 + Db::select_value("\n select count(*) from caches where status in (1,2,3)\n "), 'user_count' => 0 + Db::select_value("\n select count(*) from (\n select distinct user_id\n from cache_logs\n where\n type in (1,2,7)\n and " . (Settings::get('OC_BRANCH') == 'oc.pl' ? "deleted = 0" : "true") . "\n UNION DISTINCT\n select distinct user_id\n from caches\n ) as t;\n "), 'apps_count' => 0 + Db::select_value("select count(*) from okapi_consumers;"), 'apps_active' => 0 + Db::select_value("\n select count(distinct s.consumer_key)\n from\n okapi_stats_hourly s,\n okapi_consumers c\n where\n s.consumer_key = c.`key`\n and s.period_start > date_add(now(), interval -30 day)\n ")); Cache::set($cachekey, $result, 86400); # cache it for one day } return Okapi::formatted_response($request, $result); }
public static function call(OkapiRequest $request) { $cache_code = $request->get_parameter('cache_code'); if (!$cache_code) { throw new ParamMissing('cache_code'); } if (strpos($cache_code, "|") !== false) { throw new InvalidParam('cache_code'); } $langpref = $request->get_parameter('langpref'); if (!$langpref) { $langpref = "en"; } $langpref .= "|" . Settings::get('SITELANG'); $fields = $request->get_parameter('fields'); if (!$fields) { $fields = "code|name|location|type|status"; } $log_fields = $request->get_parameter('log_fields'); if (!$log_fields) { $log_fields = "uuid|date|user|type|comment"; } $lpc = $request->get_parameter('lpc'); if (!$lpc) { $lpc = 10; } $attribution_append = $request->get_parameter('attribution_append'); if (!$attribution_append) { $attribution_append = 'full'; } $params = array('cache_codes' => $cache_code, 'langpref' => $langpref, 'fields' => $fields, 'attribution_append' => $attribution_append, 'lpc' => $lpc, 'log_fields' => $log_fields); $my_location = $request->get_parameter('my_location'); if ($my_location) { $params['my_location'] = $my_location; } $user_uuid = $request->get_parameter('user_uuid'); if ($user_uuid) { $params['user_uuid'] = $user_uuid; } # There's no need to validate the fields/lpc parameters as the 'geocaches' # method does this (it will raise a proper exception on invalid values). $results = OkapiServiceRunner::call('services/caches/geocaches', new OkapiInternalRequest($request->consumer, $request->token, $params)); $result = $results[$cache_code]; if ($result === null) { # Two errors messages (for OCDE). Makeshift solution for issue #350. $exists = Db::select_value("\n select 1\n from caches\n where wp_oc='" . Db::escape_string($cache_code) . "'\n "); if ($exists) { throw new InvalidParam('cache_code', "This cache is not accessible via OKAPI."); } else { throw new InvalidParam('cache_code', "This cache does not exist."); } } return Okapi::formatted_response($request, $result); }
public static function call(OkapiRequest $request) { $result = array(); $result['site_url'] = Settings::get('SITE_URL'); $result['okapi_base_url'] = $result['site_url'] . "okapi/"; $result['site_name'] = Okapi::get_normalized_site_name(); $result['okapi_version_number'] = Okapi::$version_number; $result['okapi_revision'] = Okapi::$version_number; /* Important for backward-compatibility! */ $result['okapi_git_revision'] = Okapi::$git_revision; return Okapi::formatted_response($request, $result); }
public static function call(OkapiRequest $request) { require_once 'replicate_common.inc.php'; $result = array(); $result['changelog'] = array('min_since' => ReplicateCommon::get_min_since(), 'revision' => ReplicateCommon::get_revision()); $dump = Cache::get("last_fulldump"); if ($dump) { $result['latest_fulldump'] = array('revision' => $dump['revision'], 'generated_at' => $dump['meta']['generated_at'], 'size' => $dump['meta']['compressed_size'], 'size_uncompressed' => $dump['meta']['uncompressed_size']); } else { $result['latest_fulldump'] = null; } return Okapi::formatted_response($request, $result); }
public static function call(OkapiRequest $request) { $issue_id = $request->get_parameter('issue_id'); if (!$issue_id) { throw new ParamMissing('issue_id'); } if (!preg_match("/^[0-9]+\$/", $issue_id) || strlen($issue_id) > 6) { throw new InvalidParam('issue_id'); } # In October 2013, Google Code feed at: # http://code.google.com/feeds/issues/p/opencaching-api/issues/$issue_id/comments/full # stopped working. We are forced to respond with a simple placeholder. $result = array('id' => $issue_id + 0, 'last_updated' => null, 'title' => null, 'url' => "https://code.google.com/p/opencaching-api/issues/detail?id=" . $issue_id, 'comment_count' => null); return Okapi::formatted_response($request, $result); }
public static function call(OkapiRequest $request) { $username = $request->get_parameter('username'); if (!$username) { throw new ParamMissing('username'); } $fields = $request->get_parameter('fields'); # There's no need to validate the fields parameter. $results = OkapiServiceRunner::call('services/users/by_usernames', new OkapiInternalRequest($request->consumer, $request->token, array('usernames' => $username, 'fields' => $fields))); $result = $results[$username]; if ($result == null) { throw new InvalidParam('username', "There is no user by this username."); } return Okapi::formatted_response($request, $result); }
public static function call(OkapiRequest $request) { $methodnames = OkapiServiceRunner::$all_names; sort($methodnames); $cache_key = "api_ref/method_index#" . md5(implode("#", $methodnames)); $results = Cache::get($cache_key); if ($results == null) { $results = array(); foreach ($methodnames as $methodname) { $info = OkapiServiceRunner::call('services/apiref/method', new OkapiInternalRequest(new OkapiInternalConsumer(), null, array('name' => $methodname))); $results[] = array('name' => $info['name'], 'brief_description' => $info['brief_description']); } Cache::set($cache_key, $results, 3600); } return Okapi::formatted_response($request, $results); }
public static function call(OkapiRequest $request) { # Get current notes, and verify cache_code $cache_code = $request->get_parameter('cache_code'); if ($cache_code == null) { throw new ParamMissing('cache_code'); } $geocache = OkapiServiceRunner::call('services/caches/geocache', new OkapiInternalRequest($request->consumer, $request->token, array('cache_code' => $cache_code, 'fields' => 'my_notes|internal_id'))); $current_value = $geocache['my_notes']; if ($current_value == null) { $current_value = ""; } $cache_id = $geocache['internal_id']; # old_value $old_value = $request->get_parameter('old_value'); if ($old_value === null) { $old_value = ''; } # new_value (force "no HTML" policy). $new_value = $request->get_parameter('new_value'); if ($new_value === null) { throw new ParamMissing('new_value'); } # Force "no HTML" policy. $new_value = strip_tags($new_value); # Placeholders for returned values. $ret_saved_value = null; $ret_replaced = false; if (trim($current_value) == "" || self::str_equals($old_value, $current_value)) { /* REPLACE mode */ $ret_replaced = true; if (trim($new_value) == "") { /* empty new value means delete */ self::remove_notes($cache_id, $request->token->user_id); $ret_saved_value = null; } else { self::update_notes($cache_id, $request->token->user_id, $new_value); $ret_saved_value = $new_value; } } else { /* APPEND mode */ $ret_saved_value = trim($current_value) . "\n\n" . trim($new_value); self::update_notes($cache_id, $request->token->user_id, $ret_saved_value); } $result = array('saved_value' => $ret_saved_value, 'replaced' => $ret_replaced); return Okapi::formatted_response($request, $result); }
public static function call(OkapiRequest $request) { $cache_code = $request->get_parameter('cache_code'); if (!$cache_code) { throw new ParamMissing('cache_code'); } $fields = $request->get_parameter('fields'); if (!$fields) { $fields = "uuid|date|user|type|comment"; } $offset = $request->get_parameter('offset'); if (!$offset) { $offset = "0"; } if ((int) $offset != $offset || (int) $offset < 0) { throw new InvalidParam('offset', "Expecting non-negative integer."); } $limit = $request->get_parameter('limit'); if (!$limit) { $limit = "none"; } if ($limit == "none") { $limit = "999999999"; } if ((int) $limit != $limit || (int) $limit < 0) { throw new InvalidParam('limit', "Expecting non-negative integer or 'none'."); } # Check if code exists and retrieve cache ID (this will throw # a proper exception on invalid code). $cache = OkapiServiceRunner::call('services/caches/geocache', new OkapiInternalRequest($request->consumer, null, array('cache_code' => $cache_code, 'fields' => 'internal_id'))); # Cache exists. Getting the uuids of its logs. $log_uuids = Db::select_column("\n select uuid\n from cache_logs\n where\n cache_id = '" . Db::escape_string($cache['internal_id']) . "'\n and " . (Settings::get('OC_BRANCH') == 'oc.pl' ? "deleted = 0" : "true") . "\n order by date desc\n limit {$offset}, {$limit}\n "); # Getting the logs themselves. Formatting as an ordered list. $internal_request = new OkapiInternalRequest($request->consumer, $request->token, array('log_uuids' => implode("|", $log_uuids), 'fields' => $fields)); $internal_request->skip_limits = true; $logs = OkapiServiceRunner::call('services/logs/entries', $internal_request); $results = array(); foreach ($log_uuids as $log_uuid) { $results[] = $logs[$log_uuid]; } /* Handle OCPL's "access logs" feature. */ if (Settings::get('OC_BRANCH') == 'oc.pl' && Settings::get('OCPL_ENABLE_GEOCACHE_ACCESS_LOGS') && count($log_uuids) > 0) { require_once $GLOBALS['rootpath'] . 'okapi/lib/ocpl_access_logs.php'; \okapi\OCPLAccessLogs::log_geocache_access($request, $cache['internal_id']); } return Okapi::formatted_response($request, $results); }
public static function call(OkapiRequest $request) { $cache_code = $request->get_parameter('cache_code'); if (!$cache_code) { throw new ParamMissing('cache_code'); } if (strpos($cache_code, "|") !== false) { throw new InvalidParam('cache_code'); } $langpref = $request->get_parameter('langpref'); if (!$langpref) { $langpref = "en|" . Settings::get('SITELANG'); } $fields = $request->get_parameter('fields'); if (!$fields) { $fields = "code|name|location|type|status"; } $log_fields = $request->get_parameter('log_fields'); if (!$log_fields) { $log_fields = "uuid|date|user|type|comment"; } $lpc = $request->get_parameter('lpc'); if (!$lpc) { $lpc = 10; } $attribution_append = $request->get_parameter('attribution_append'); if (!$attribution_append) { $attribution_append = 'full'; } $params = array('cache_codes' => $cache_code, 'langpref' => $langpref, 'fields' => $fields, 'attribution_append' => $attribution_append, 'lpc' => $lpc, 'log_fields' => $log_fields); $my_location = $request->get_parameter('my_location'); if ($my_location) { $params['my_location'] = $my_location; } $user_uuid = $request->get_parameter('user_uuid'); if ($user_uuid) { $params['user_uuid'] = $user_uuid; } # There's no need to validate the fields/lpc parameters as the 'geocaches' # method does this (it will raise a proper exception on invalid values). $results = OkapiServiceRunner::call('services/caches/geocaches', new OkapiInternalRequest($request->consumer, $request->token, $params)); $result = $results[$cache_code]; if ($result === null) { throw new InvalidParam('cache_code', "This cache does not exist."); } return Okapi::formatted_response($request, $result); }
public static function call(OkapiRequest $request) { $log_uuid = $request->get_parameter('log_uuid'); if (!$log_uuid) { throw new ParamMissing('log_uuid'); } $fields = $request->get_parameter('fields'); if (!$fields) { $fields = "date|user|type|comment"; } $results = OkapiServiceRunner::call('services/logs/entries', new OkapiInternalRequest($request->consumer, $request->token, array('log_uuids' => $log_uuid, 'fields' => $fields))); $result = $results[$log_uuid]; if ($result == null) { throw new InvalidParam('log_uuid', "This log entry does not exist."); } return Okapi::formatted_response($request, $result); }
public static function call(OkapiRequest $request) { $result = array(); $result['site_url'] = Settings::get('SITE_URL'); $result['okapi_base_url'] = Okapi::get_recommended_base_url(); $result['okapi_base_urls'] = Okapi::get_allowed_base_urls(); $result['site_name'] = Okapi::get_normalized_site_name(); $result['okapi_version_number'] = Okapi::$version_number; $result['okapi_revision'] = Okapi::$version_number; /* Important for backward-compatibility! */ $result['okapi_git_revision'] = Okapi::$git_revision; $result['registration_url'] = Settings::get('REGISTRATION_URL'); $result['mobile_registration_url'] = Settings::get('MOBILE_REGISTRATION_URL'); $result['image_max_upload_size'] = Settings::get('IMAGE_MAX_UPLOAD_SIZE'); $result['image_rcmd_max_pixels'] = Settings::get('IMAGE_MAX_PIXEL_COUNT'); return Okapi::formatted_response($request, $result); }
public static function call(OkapiRequest $request) { require_once 'replicate_common.inc.php'; $since = $request->get_parameter('since'); if ($since === null) { throw new ParamMissing('since'); } if ((int) $since != $since) { throw new InvalidParam('since'); } # Let's check the $since parameter. if (!ReplicateCommon::check_since_param($since)) { throw new BadRequest("The 'since' parameter is too old. You must update your database more frequently."); } # Select a best chunk for the given $since, get the chunk from the database (or cache). list($from, $to) = ReplicateCommon::select_best_chunk($since); $clog_entries = ReplicateCommon::get_chunk($from, $to); $result = array('changelog' => &$clog_entries, 'revision' => $to + 0, 'more' => $to < ReplicateCommon::get_revision()); return Okapi::formatted_response($request, $result); }
public static function call(OkapiRequest $request) { $user_uuid = $request->get_parameter('user_uuid'); if (!$user_uuid) { if ($request->token) { $tmp = OkapiServiceRunner::call('services/users/by_internal_id', new OkapiInternalRequest($request->consumer, null, array('internal_id' => $request->token->user_id, 'fields' => 'uuid'))); $user_uuid = $tmp['uuid']; } else { throw new BadRequest("You must either: 1. supply the user_uuid argument, or " . "2. sign your request with an Access Token."); } } $fields = $request->get_parameter('fields'); # There's no need to validate the fields parameter as the 'users' # method does this (it will raise a proper exception on invalid values). $results = OkapiServiceRunner::call('services/users/users', new OkapiInternalRequest($request->consumer, $request->token, array('user_uuids' => $user_uuid, 'fields' => $fields))); $result = $results[$user_uuid]; if ($result == null) { throw new InvalidParam('user_uuid', "There is no user by this ID."); } return Okapi::formatted_response($request, $result); }
public static function call(OkapiRequest $request) { $usernames = $request->get_parameter('usernames'); if (!$usernames) { throw new ParamMissing('usernames'); } $usernames = explode("|", $usernames); if (count($usernames) > 500) { throw new InvalidParam('usernames', "Maximum allowed number of referenced users " . "is 500. You provided " . count($usernames) . " usernames."); } $fields = $request->get_parameter('fields'); if (!$fields) { throw new ParamMissing('fields'); } # There's no need to validate the fields parameter as the 'users' # method does this (it will raise a proper exception on invalid values). $rs = Db::query("\n select username, uuid\n from user\n where username collate " . Settings::get('DB_CHARSET') . "_general_ci in ('" . implode("','", array_map('\\okapi\\Db::escape_string', $usernames)) . "')\n "); $lower_username2useruuid = array(); while ($row = Db::fetch_assoc($rs)) { $lower_username2useruuid[mb_strtolower($row['username'], 'utf-8')] = $row['uuid']; } Db::free_result($rs); # Retrieve data for the found user_uuids. if (count($lower_username2useruuid) > 0) { $id_results = OkapiServiceRunner::call('services/users/users', new OkapiInternalRequest($request->consumer, $request->token, array('user_uuids' => implode("|", array_values($lower_username2useruuid)), 'fields' => $fields))); } else { $id_results = array(); } # Map user_uuids back to usernames. Also check which usernames were not found # and mark them with null. $results = array(); foreach ($usernames as $username) { if (!isset($lower_username2useruuid[mb_strtolower($username, 'utf-8')])) { $results[$username] = null; } else { $results[$username] = $id_results[$lower_username2useruuid[mb_strtolower($username, 'utf-8')]]; } } return Okapi::formatted_response($request, $results); }
public static function call(OkapiRequest $request) { $user_uuid = $request->get_parameter('user_uuid'); if (!$user_uuid) { throw new ParamMissing('user_uuid'); } $limit = $request->get_parameter('limit'); if (!$limit) { $limit = "20"; } if (!is_numeric($limit)) { throw new InvalidParam('limit', "'{$limit}'"); } $limit = intval($limit); if ($limit < 1 || $limit > 1000) { throw new InvalidParam('limit', "Has to be in range 1..1000."); } $offset = $request->get_parameter('offset'); if (!$offset) { $offset = "0"; } if (!is_numeric($offset)) { throw new InvalidParam('offset', "'{$offset}'"); } $offset = intval($offset); if ($offset < 0) { throw new InvalidParam('offset', "'{$offset}'"); } # Check if user exists and retrieve user's ID (this will throw # a proper exception on invalid UUID). $user = OkapiServiceRunner::call('services/users/user', new OkapiInternalRequest($request->consumer, null, array('user_uuid' => $user_uuid, 'fields' => 'internal_id'))); # User exists. Retrieving logs. $rs = Db::query("\n select cl.id, cl.uuid, cl.type, unix_timestamp(cl.date) as date, cl.text,\n c.wp_oc as cache_code\n from cache_logs cl, caches c\n where\n cl.user_id = '" . Db::escape_string($user['internal_id']) . "'\n and " . (Settings::get('OC_BRANCH') == 'oc.pl' ? "cl.deleted = 0" : "true") . "\n and c.status in (1,2,3)\n and cl.cache_id = c.cache_id\n order by cl.date desc\n limit {$offset}, {$limit}\n "); $results = array(); while ($row = Db::fetch_assoc($rs)) { $results[] = array('uuid' => $row['uuid'], 'date' => date('c', $row['date']), 'cache_code' => $row['cache_code'], 'type' => Okapi::logtypeid2name($row['type']), 'comment' => $row['text']); } return Okapi::formatted_response($request, $results); }
public static function call(OkapiRequest $request) { # "Cache control" parameters. $tmp = $request->get_parameter('min_store'); if ($tmp === null) { $tmp = "300"; } $min_store = intval($tmp); if ("{$min_store}" !== $tmp || $min_store < 0 || $min_store > 64800) { throw new InvalidParam('min_store', "Has to be in the 0..64800 range."); } $tmp = $request->get_parameter('ref_max_age'); if ($tmp === null) { $tmp = "300"; } if ($tmp == "nolimit") { $tmp = "9999999"; } $ref_max_age = intval($tmp); if ("{$ref_max_age}" !== $tmp || $ref_max_age < 300) { throw new InvalidParam('ref_max_age', "Has to be >=300."); } # Search params. $search_assistant = new SearchAssistant($request); $search_assistant->prepare_common_search_params(); $search_params = $search_assistant->get_search_params(); $tables = array_merge(array('caches'), $search_params['extra_tables']); $where_conds = array_merge(array('caches.wp_oc is not null'), $search_params['where_conds']); if (isset($search_params['extra_joins']) && is_array($search_params['extra_joins'])) { $joins = $search_params['extra_joins']; } else { $joins = array(); } unset($search_params); # Generate, or retrieve an existing set, and return the result. # All user-supplied data in $tables and $where_conds MUST be escaped! $result = self::get_set($tables, $joins, $where_conds, $min_store, $ref_max_age); return Okapi::formatted_response($request, $result); }
public static function call(OkapiRequest $request) { # Read the parameters. $langpref = $request->get_parameter('langpref'); if (!$langpref) { $langpref = "en"; } $fields = $request->get_parameter('fields'); if (!$fields) { $fields = "name"; } $only_locally_used = $request->get_parameter('only_locally_used'); if (!$only_locally_used) { $only_locally_used = "false"; } $only_locally_used = $only_locally_used == "true"; # Get the list of attributes and filter the A-codes based on the # parameters. require_once 'attr_helper.inc.php'; $attrdict = AttrHelper::get_attrdict(); $acodes = array(); foreach ($attrdict as $acode => &$attr_ref) { if ($only_locally_used && $attr_ref['internal_id'] === null) { /* Skip. */ continue; } $acodes[] = $acode; } # Retrieve the attribute objects and return the results. if (count($acodes) > 0) { $params = array('acodes' => implode("|", $acodes), 'langpref' => $langpref, 'fields' => $fields); $results = OkapiServiceRunner::call('services/attrs/attributes', new OkapiInternalRequest($request->consumer, $request->token, $params)); } else { $results = new ArrayObject(); } return Okapi::formatted_response($request, $results); }
public static function call(OkapiRequest $request) { $internal_ids = $request->get_parameter('internal_ids'); if (!$internal_ids) { throw new ParamMissing('internal_ids'); } $internal_ids = explode("|", $internal_ids); if (count($internal_ids) > 500) { throw new InvalidParam('internal_ids', "Maximum allowed number of referenced users " . "is 500. You provided " . count($internal_ids) . " references."); } $fields = $request->get_parameter('fields'); if (!$fields) { throw new ParamMissing('fields'); } # There's no need to validate the fields parameter as the 'users' # method does this (it will raise a proper exception on invalid values). $rs = Db::query("\n select user_id, uuid\n from user\n where user_id in ('" . implode("','", array_map('mysql_real_escape_string', $internal_ids)) . "')\n "); $internalid2useruuid = array(); while ($row = mysql_fetch_assoc($rs)) { $internalid2useruuid[$row['user_id']] = $row['uuid']; } mysql_free_result($rs); # Retrieve data on given user_uuids. $id_results = OkapiServiceRunner::call('services/users/users', new OkapiInternalRequest($request->consumer, $request->token, array('user_uuids' => implode("|", array_values($internalid2useruuid)), 'fields' => $fields))); # Map user_uuids to internal_ids. Also check which internal_ids were not found # and mark them with null. $results = array(); foreach ($internal_ids as $internal_id) { if (!isset($internalid2useruuid[$internal_id])) { $results[$internal_id] = null; } else { $results[$internal_id] = $id_results[$internalid2useruuid[$internal_id]]; } } return Okapi::formatted_response($request, $results); }
public static function call(OkapiRequest $request) { # Retrieve the list of URLs to check. $tmp = $request->get_parameter('urls'); if (!$tmp) { throw new ParamMissing('urls'); } $urls = explode('|', $tmp); $as_dict = $request->get_parameter('as_dict'); if (!$as_dict) { $as_dict = 'false'; } if (!in_array($as_dict, array('true', 'false'))) { throw new InvalidParam('as_dict'); } $as_dict = $as_dict == 'true'; # Generate the lists of keys. $results = array(); $urls_with = array('cache_code' => array(), 'internal_id' => array(), 'uuid' => array()); foreach ($urls as &$url_ref) { $key = self::get_cache_key($url_ref); if ($key != null) { $urls_with[$key[0]][$url_ref] = $key[1]; } else { $results[$url_ref] = null; } } # Include 'cache_code' references. foreach ($urls_with['cache_code'] as $url => $cache_code) { $results[$url] = $cache_code; } # Include 'internal_id' references. $internal_ids = array_values($urls_with['internal_id']); if (count($internal_ids) > 0) { $rs = Db::query("\n select cache_id, wp_oc\n from caches\n where\n cache_id in ('" . implode("','", array_map('mysql_real_escape_string', $internal_ids)) . "')\n and status in (1,2,3)\n "); $dict = array(); while ($row = mysql_fetch_assoc($rs)) { $dict[$row['cache_id']] = $row['wp_oc']; } foreach ($urls_with['internal_id'] as $url => $internal_id) { if (isset($dict[$internal_id])) { $results[$url] = $dict[$internal_id]; } else { $results[$url] = null; } } } # Include 'uuid' references. $uuids = array_values($urls_with['uuid']); if (count($uuids) > 0) { $rs = Db::query("\n select uuid, wp_oc\n from caches\n where\n uuid in ('" . implode("','", array_map('mysql_real_escape_string', $uuids)) . "')\n and status in (1,2,3)\n "); $dict = array(); while ($row = mysql_fetch_assoc($rs)) { $dict[$row['uuid']] = $row['wp_oc']; } foreach ($urls_with['uuid'] as $url => $uuid) { if (isset($dict[$uuid])) { $results[$url] = $dict[$uuid]; } else { $results[$url] = null; } } } # Format the results according to the 'as_dict' parameter. if ($as_dict) { return Okapi::formatted_response($request, $results); } else { $cache_codes = array(); foreach ($results as $url => $cache_code) { if ($cache_code != null) { $cache_codes[$cache_code] = true; } } $flattened = array('results' => array_keys($cache_codes)); return Okapi::formatted_response($request, $flattened); } }
public static function call(OkapiRequest $request) { # You may wonder, why there are no parameters like "bbox" or "center" in the # "search/all" method. This is *intentional* and should be kept this way. # Such parameters would fall in conflict with each other and - in result - # make the documentation very fuzzy. That's why they were intentionally # left out of the "search/all" method, and put in separate (individual) ones. # It's much easier to grasp their meaning this way. $tmp = $request->get_parameter('bbox'); if (!$tmp) { throw new ParamMissing('bbox'); } $parts = explode('|', $tmp); if (count($parts) != 4) { throw new InvalidParam('bbox', "Expecting 4 pipe-separated parts, got " . count($parts) . "."); } foreach ($parts as &$part_ref) { if (!preg_match("/^-?[0-9]+(\\.?[0-9]*)\$/", $part_ref)) { throw new InvalidParam('bbox', "'{$part_ref}' is not a valid float number."); } $part_ref = floatval($part_ref); } list($bbsouth, $bbwest, $bbnorth, $bbeast) = $parts; if ($bbnorth <= $bbsouth) { throw new InvalidParam('bbox', "Northern edge must be situated to the north of the southern edge."); } if ($bbeast == $bbwest) { throw new InvalidParam('bbox', "Eastern edge longitude is the same as the western one."); } if ($bbnorth > 90 || $bbnorth < -90 || $bbsouth > 90 || $bbsouth < -90) { throw new InvalidParam('bbox', "Latitudes have to be within -90..90 range."); } if ($bbeast > 180 || $bbeast < -180 || $bbwest > 180 || $bbwest < -180) { throw new InvalidParam('bbox', "Longitudes have to be within -180..180 range."); } # Construct SQL conditions for the specified bounding box. $search_assistant = new SearchAssistant($request); $search_assistant->prepare_common_search_params(); $search_assistant->prepare_location_search_params(); $where_conds = array(); $lat = $search_assistant->get_latitude_expr(); $lon = $search_assistant->get_longitude_expr(); $where_conds[] = "(\n {$lat} >= '" . Db::escape_string($bbsouth) . "'\n and {$lat} < '" . Db::escape_string($bbnorth) . "'\n )"; if ($bbeast > $bbwest) { # Easy one. $where_conds[] = "(\n {$lon} >= '" . Db::escape_string($bbwest) . "'\n and {$lon} < '" . Db::escape_string($bbeast) . "'\n )"; } else { # We'll have to assume that this bbox goes through the 180-degree meridian. # For example, $bbwest = 179 and $bbeast = -179. $where_conds[] = "(\n {$lon} >= '" . Db::escape_string($bbwest) . "'\n or {$lon} < '" . Db::escape_string($bbeast) . "'\n )"; } # # In the method description, we promised to return caches ordered by the *rough* # distance from the center of the bounding box. We'll use ORDER BY with a simplified # distance formula and combine it with the LIMIT clause to get the best results. # $center_lat = ($bbsouth + $bbnorth) / 2.0; $center_lon = ($bbwest + $bbeast) / 2.0; $search_params = $search_assistant->get_search_params(); $search_params['where_conds'] = array_merge($where_conds, $search_params['where_conds']); $search_params['order_by'][] = Okapi::get_distance_sql($center_lat, $center_lon, $search_assistant->get_latitude_expr(), $search_assistant->get_longitude_expr()); # not replaced; added to the end! $search_assistant->set_search_params($search_params); $result = $search_assistant->get_common_search_result(); return Okapi::formatted_response($request, $result); }
public static function call(OkapiRequest $request) { # You may wonder, why there are no parameters like "bbox" or "center" in the # "search/all" method. This is *intentional* and should be kept this way. # Such parameters would fall in conflict with each other and - in result - # make the documentation very fuzzy. That's why they were intentionally # left out of the "search/all" method, and put in separate (individual) ones. # It's much easier to grasp their meaning this way. $tmp = $request->get_parameter('center'); if (!$tmp) { throw new ParamMissing('center'); } $parts = explode('|', $tmp); if (count($parts) != 2) { throw new InvalidParam('center', "Expecting 2 pipe-separated parts, got " . count($parts) . "."); } foreach ($parts as &$part_ref) { if (!preg_match("/^-?[0-9]+(\\.?[0-9]*)\$/", $part_ref)) { throw new InvalidParam('center', "'{$part_ref}' is not a valid float number."); } $part_ref = floatval($part_ref); } list($center_lat, $center_lon) = $parts; if ($center_lat > 90 || $center_lat < -90) { throw new InvalidParam('center', "Latitudes have to be within -90..90 range."); } if ($center_lon > 180 || $center_lon < -180) { throw new InvalidParam('center', "Longitudes have to be within -180..180 range."); } # # In the method description, we promised to return caches ordered by the *rough* # distance from the center point. We'll use ORDER BY with a simplified distance # formula and combine it with the LIMIT clause to get the best results. # $search_assistant = new SearchAssistant($request); $search_assistant->prepare_common_search_params(); $search_assistant->prepare_location_search_params(); $distance_formula = Okapi::get_distance_sql($center_lat, $center_lon, $search_assistant->get_latitude_expr(), $search_assistant->get_longitude_expr()); # 'radius' parameter is optional. If not given, we'll have to calculate the # distance for every cache in the database. $where_conds = array(); $radius = null; if ($tmp = $request->get_parameter('radius')) { if (!preg_match("/^-?[0-9]+(\\.?[0-9]*)\$/", $tmp)) { throw new InvalidParam('radius', "'{$tmp}' is not a valid float number."); } $radius = floatval($tmp); # is given in kilometers if ($radius <= 0) { throw new InvalidParam('radius', "Has to be a positive number."); } # Apply a latitude-range prefilter if it looks promising. # See https://github.com/opencaching/okapi/issues/363 for more info. $optimization_radius = 100; # in kilometers, optimized for Opencaching.de $km2degrees_upper_estimate_factor = 0.01; if ($radius <= $optimization_radius) { $radius_degrees = $radius * $km2degrees_upper_estimate_factor; $where_conds[] = "\n caches.latitude >= '" . Db::escape_string($center_lat - $radius_degrees) . "'\n and caches.latitude <= '" . Db::escape_string($center_lat + $radius_degrees) . "'\n "; } $radius *= 1000; # convert from kilometers to meters $where_conds[] = "{$distance_formula} <= '" . Db::escape_string($radius) . "'"; } $search_params = $search_assistant->get_search_params(); $search_params['where_conds'] = array_merge($where_conds, $search_params['where_conds']); $search_params['caches_indexhint'] = "use index (latitude)"; $search_params['order_by'][] = $distance_formula; # not replaced; added to the end! $search_assistant->set_search_params($search_params); $result = $search_assistant->get_common_search_result(); if ($radius == null) { # 'more' is meaningless in this case, we'll remove it. unset($result['more']); } return Okapi::formatted_response($request, $result); }
public static function call(OkapiRequest $request) { $methodname = $request->get_parameter('name'); if (!$methodname) { throw new ParamMissing('name'); } if (!preg_match("#^services/[0-9a-z_/]*\$#", $methodname)) { throw new InvalidParam('name'); } if (!OkapiServiceRunner::exists($methodname)) { throw new InvalidParam('name', "Method does not exist: '{$methodname}'."); } $options = OkapiServiceRunner::options($methodname); if (!isset($options['min_auth_level'])) { throw new Exception("Method {$methodname} is missing a required 'min_auth_level' option!"); } $docs = simplexml_load_string(OkapiServiceRunner::docs($methodname)); $exploded = explode("/", $methodname); $result = array('name' => $methodname, 'short_name' => end($exploded), 'ref_url' => Settings::get('SITE_URL') . "okapi/{$methodname}.html", 'auth_options' => array('min_auth_level' => $options['min_auth_level'], 'oauth_consumer' => $options['min_auth_level'] >= 2, 'oauth_token' => $options['min_auth_level'] >= 3)); if (!$docs->brief) { throw new Exception("Missing <brief> element in the {$methodname}.xml file."); } if ($docs->brief != self::get_inner_xml($docs->brief)) { throw new Exception("The <brief> element may not contain HTML markup ({$methodname}.xml)."); } if (strlen($docs->brief) > 80) { throw new Exception("The <brief> description may not be longer than 80 characters ({$methodname}.xml)."); } if (strpos($docs->brief, "\n") !== false) { throw new Exception("The <brief> element may not contain new-lines ({$methodname}.xml)."); } if (substr(trim($docs->brief), -1) == '.') { throw new Exception("The <brief> element should not end with a dot ({$methodname}.xml)."); } $result['brief_description'] = self::get_inner_xml($docs->brief); if ($docs->{'issue-id'}) { $result['issue_id'] = (string) $docs->{'issue-id'}; } else { $result['issue_id'] = null; } if (!$docs->desc) { throw new Exception("Missing <desc> element in the {$methodname}.xml file."); } $result['description'] = self::get_inner_xml($docs->desc); $result['arguments'] = array(); foreach ($docs->req as $arg) { $result['arguments'][] = self::arg_desc($arg); } foreach ($docs->opt as $arg) { $result['arguments'][] = self::arg_desc($arg); } foreach ($docs->{'import-params'} as $import_desc) { $attrs = $import_desc->attributes(); $referenced_methodname = $attrs['method']; $referenced_method_info = OkapiServiceRunner::call('services/apiref/method', new OkapiInternalRequest(new OkapiInternalConsumer(), null, array('name' => $referenced_methodname))); $include_list = isset($attrs['params']) ? explode("|", $attrs['params']) : null; $exclude_list = isset($attrs['except']) ? explode("|", $attrs['except']) : array(); foreach ($referenced_method_info['arguments'] as $arg) { if ($arg['class'] == 'common-formatting') { continue; } if ($include_list === null && count($exclude_list) == 0) { $arg['description'] = "<i>Inherited from <a href='" . $referenced_method_info['ref_url'] . "#arg_" . $arg['name'] . "'>" . $referenced_method_info['name'] . "</a> method.</i>"; } elseif (($include_list === null || in_array($arg['name'], $include_list)) && !in_array($arg['name'], $exclude_list)) { $arg['description'] = "<i>Same as in the <a href='" . $referenced_method_info['ref_url'] . "#arg_" . $arg['name'] . "'>" . $referenced_method_info['name'] . "</a> method.</i>"; } else { continue; } $arg['class'] = 'inherited'; $result['arguments'][] = $arg; } } if ($docs->{'common-format-params'}) { $result['arguments'][] = array('name' => 'format', 'is_required' => false, 'is_deprecated' => false, 'class' => 'common-formatting', 'description' => "<i>Standard <a href='" . Settings::get('SITE_URL') . "okapi/introduction.html#common-formatting'>common formatting</a> argument.</i>"); $result['arguments'][] = array('name' => 'callback', 'is_required' => false, 'is_deprecated' => false, 'class' => 'common-formatting', 'description' => "<i>Standard <a href='" . Settings::get('SITE_URL') . "okapi/introduction.html#common-formatting'>common formatting</a> argument.</i>"); } foreach ($result['arguments'] as &$arg_ref) { if ($arg_ref['is_deprecated']) { $arg_ref['class'] .= " deprecated"; } } if (!$docs->returns) { throw new Exception("Missing <returns> element in the {$methodname}.xml file. " . "If your method does not return anything, you should document in nonetheless."); } $result['returns'] = self::get_inner_xml($docs->returns); return Okapi::formatted_response($request, $result); }
public static function call(OkapiRequest $request) { $user_uuids = $request->get_parameter('user_uuids'); if (!$user_uuids) { throw new ParamMissing('user_uuids'); } $user_uuids = explode("|", $user_uuids); if (count($user_uuids) > 500) { throw new InvalidParam('user_uuids', "Maximum allowed number of referenced users " . "is 500. You provided " . count($user_uuids) . " user IDs."); } $fields = $request->get_parameter('fields'); if (!$fields) { throw new ParamMissing('fields'); } $fields = explode("|", $fields); foreach ($fields as $field) { if (!in_array($field, self::$valid_field_names)) { throw new InvalidParam('fields', "'{$field}' is not a valid field code."); } } $rs = Db::query("\n select user_id, uuid, username, admin, latitude, longitude, date_created\n from user\n where uuid in ('" . implode("','", array_map('\\okapi\\Db::escape_string', $user_uuids)) . "')\n "); $results = array(); $id2uuid = array(); $uuid2id = array(); while ($row = Db::fetch_assoc($rs)) { $id2uuid[$row['user_id']] = $row['uuid']; $uuid2id[$row['uuid']] = $row['user_id']; $entry = array(); foreach ($fields as $field) { switch ($field) { case 'uuid': $entry['uuid'] = $row['uuid']; break; case 'username': $entry['username'] = $row['username']; break; case 'profile_url': $entry['profile_url'] = Settings::get('SITE_URL') . "viewprofile.php?userid=" . $row['user_id']; break; case 'is_admin': if (!$request->token) { $entry['is_admin'] = null; } elseif ($request->token->user_id != $row['user_id']) { $entry['is_admin'] = null; } else { $entry['is_admin'] = $row['admin'] ? true : false; } break; case 'internal_id': $entry['internal_id'] = $row['user_id']; break; case 'date_registered': $entry['date_registered'] = date("Y-m-d", strtotime($row['date_created'])); case 'caches_found': /* handled separately */ break; case 'caches_notfound': /* handled separately */ break; case 'caches_hidden': /* handled separately */ break; case 'rcmds_given': /* handled separately */ break; case 'home_location': if (!$request->token) { $entry['home_location'] = null; } elseif ($request->token->user_id != $row['user_id']) { $entry['home_location'] = null; } elseif (!$row['latitude'] && !$row['longitude']) { # OCPL sets NULL/NULL for unknown location, OCDE sets 0/0. # It is safe to return null also for OCPL 0/0, as this value # does not make sense. $entry['home_location'] = null; } else { $entry['home_location'] = round($row['latitude'], 6) . "|" . round($row['longitude'], 6); } break; default: throw new Exception("Missing field case: " . $field); } } $results[$row['uuid']] = $entry; } Db::free_result($rs); # caches_found, caches_notfound, caches_hidden if (in_array('caches_found', $fields) || in_array('caches_notfound', $fields) || in_array('caches_hidden', $fields) || in_array('rcmds_given', $fields)) { # We will load all these stats together. Then we may remove these which # the user doesn't need. $extras = array(); if (Settings::get('OC_BRANCH') == 'oc.pl') { # OCPL stores user stats in 'user' table. $rs = Db::query("\n select user_id, founds_count, notfounds_count, hidden_count\n from user\n where user_id in ('" . implode("','", array_map('\\okapi\\Db::escape_string', array_keys($id2uuid))) . "')\n "); } else { # OCDE stores user stats in 'stat_user' table. $rs = Db::query("\n select\n u.user_id,\n ifnull(su.found, 0) as founds_count,\n ifnull(su.notfound, 0) as notfounds_count,\n ifnull(su.hidden, 0) as hidden_count\n from\n user u\n left join stat_user su\n on su.user_id = u.user_id\n where u.user_id in ('" . implode("','", array_map('\\okapi\\Db::escape_string', array_keys($id2uuid))) . "')\n "); } while ($row = Db::fetch_assoc($rs)) { $extras[$row['user_id']] = array(); $extra_ref =& $extras[$row['user_id']]; $extra_ref['caches_found'] = 0 + $row['founds_count']; $extra_ref['caches_notfound'] = 0 + $row['notfounds_count']; $extra_ref['caches_hidden'] = 0 + $row['hidden_count']; } Db::free_result($rs); if (in_array('rcmds_given', $fields)) { $rs = Db::query("\n select user_id, count(*) as rcmds_given\n from cache_rating\n where user_id in ('" . implode("','", array_map('\\okapi\\Db::escape_string', array_keys($id2uuid))) . "')\n group by user_id\n "); $rcmds_counts = array(); while ($row = Db::fetch_assoc($rs)) { $rcmds_counts[$row['user_id']] = $row['rcmds_given']; } foreach ($extras as $user_id => &$extra_ref) { $extra_ref['rcmds_given'] = isset($rcmds_counts[$user_id]) ? 0 + $rcmds_counts[$user_id] : 0; } } # "Apply" only those fields which the consumer wanted. foreach (array('caches_found', 'caches_notfound', 'caches_hidden', 'rcmds_given') as $field) { if (!in_array($field, $fields)) { continue; } foreach ($results as $uuid => &$result_ref) { $result_ref[$field] = $extras[$uuid2id[$uuid]][$field]; } } } # Check which user IDs were not found and mark them with null. foreach ($user_uuids as $user_uuid) { if (!isset($results[$user_uuid])) { $results[$user_uuid] = null; } } return Okapi::formatted_response($request, $results); }