public static function call()
{
$langpref = isset($_GET['langpref']) ? $_GET['langpref'] : Settings::get('SITELANG');
$langprefs = explode("|", $langpref);
# Determine which user is logged in to OC.
require_once $GLOBALS['rootpath'] . "okapi/lib/oc_session.php";
$OC_user_id = OCSession::get_user_id();
if ($OC_user_id == null) {
$after_login = "******" . ($langpref != Settings::get('SITELANG') ? "?langpref=" . $langpref : "");
$login_url = Settings::get('SITE_URL') . "login.php?target=" . urlencode($after_login);
return new OkapiRedirectResponse($login_url);
}
# Get the list of authorized apps.
$rs = Db::query("\n select c.`key`, c.name, c.url\n from\n okapi_consumers c,\n okapi_authorizations a\n where\n a.user_id = '" . mysql_real_escape_string($OC_user_id) . "'\n and c.`key` = a.consumer_key\n order by c.name\n ");
$vars = array();
$vars['okapi_base_url'] = Settings::get('SITE_URL') . "okapi/";
$vars['site_url'] = Settings::get('SITE_URL');
$vars['site_name'] = Okapi::get_normalized_site_name();
$vars['site_logo'] = Settings::get('SITE_LOGO');
$vars['apps'] = array();
while ($row = mysql_fetch_assoc($rs)) {
$vars['apps'][] = $row;
}
mysql_free_result($rs);
$response = new OkapiHttpResponse();
$response->content_type = "text/html; charset=utf-8";
ob_start();
Okapi::gettext_domain_init($langprefs);
include 'index.tpl.php';
$response->body = ob_get_clean();
Okapi::gettext_domain_restore();
return $response;
}
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)
{
$search_assistant = new SearchAssistant($request);
$search_assistant->prepare_common_search_params();
$result = $search_assistant->get_common_search_result();
return Okapi::formatted_response($request, $result);
}
public function new_access_token($token, $consumer, $verifier = null)
{
if ($token->consumer_key != $consumer->key) {
throw new BadRequest("Request Token given is not associated with the Consumer who signed the request.");
}
if (!$token->authorized_by_user_id) {
throw new BadRequest("Request Token given has not been authorized.");
}
if ($token->verifier != $verifier) {
throw new BadRequest("Invalid verifier.");
}
# Invalidate the Request Token.
Db::execute("\n delete from okapi_tokens\n where `key` = '" . Db::escape_string($token->key) . "'\n ");
# In OKAPI, all Access Tokens are long lived. Therefore, we don't want
# to generate a new one every time a Consumer wants it. We will check
# if there is already an Access Token generated for this (Consumer, User)
# pair and return it if there is.
$row = Db::select_row("\n select `key`, secret\n from okapi_tokens\n where\n token_type = 'access'\n and user_id = '" . Db::escape_string($token->authorized_by_user_id) . "'\n and consumer_key = '" . Db::escape_string($consumer->key) . "'\n ");
if ($row) {
# Use existing Access Token
$access_token = new OkapiAccessToken($row['key'], $row['secret'], $consumer->key, $token->authorized_by_user_id);
} else {
# Generate a new Access Token.
$access_token = new OkapiAccessToken(Okapi::generate_key(20), Okapi::generate_key(40), $consumer->key, $token->authorized_by_user_id);
Db::execute("\n insert into okapi_tokens\n (`key`, secret, token_type, timestamp, user_id, consumer_key)\n values (\n '" . Db::escape_string($access_token->key) . "',\n '" . Db::escape_string($access_token->secret) . "',\n 'access',\n unix_timestamp(),\n '" . Db::escape_string($access_token->user_id) . "',\n '" . Db::escape_string($consumer->key) . "'\n );\n ");
}
return $access_token;
}
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);
}
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);
}
/**
* Execute the method and return the result.
*
* OKAPI methods return OkapiHttpResponses, but some MAY also return
* PHP objects (see OkapiRequest::construct_inside_request for details).
*
* If $request must be consistent with given method's options (must
* include Consumer and Token, if they are required).
*/
public static function call($service_name, OkapiRequest $request)
{
Okapi::init_internals();
if (!self::exists($service_name)) {
throw new Exception("Method does not exist: '{$service_name}'");
}
$options = self::options($service_name);
if ($options['min_auth_level'] >= 2 && $request->consumer == null) {
throw new Exception("Method '{$service_name}' called with mismatched OkapiRequest: " . "\$request->consumer MAY NOT be empty for Level 2 and Level 3 methods. Provide " . "a dummy Consumer if you have to.");
}
if ($options['min_auth_level'] >= 3 && $request->token == null) {
throw new Exception("Method '{$service_name}' called with mismatched OkapiRequest: " . "\$request->token MAY NOT be empty for Level 3 methods.");
}
$time_started = microtime(true);
Okapi::gettext_domain_init();
try {
require_once $GLOBALS['rootpath'] . "okapi/{$service_name}.php";
$response = call_user_func(array('\\okapi\\' . str_replace('/', '\\', $service_name) . '\\WebService', 'call'), $request);
Okapi::gettext_domain_restore();
} catch (Exception $e) {
Okapi::gettext_domain_restore();
throw $e;
}
$runtime = microtime(true) - $time_started;
# Log the request to the stats table. Only valid requests (these which didn't end up
# with an exception) are logged.
self::save_stats($service_name, $request, $runtime);
return $response;
}
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)
{
$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()
{
ignore_user_abort(true);
set_time_limit(0);
header("Content-Type: text/plain; charset=utf-8");
# Uncomment the following if you want to debug a specific cronjob. It will be run
# every 5 minutes (run 'crontab -e' to change or disable it) AND additionally
# every time you visit http://yoursite/okapi/cron5
# require_once($GLOBALS['rootpath']."okapi/cronjobs.php"); CronJobController::force_run("JOB_NAME"); die();
Okapi::execute_cron5_cronjobs();
}
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()
{
require_once $GLOBALS['rootpath'] . 'okapi/service_runner.php';
require_once $GLOBALS['rootpath'] . 'okapi/views/menu.inc.php';
$vars = array('menu' => OkapiMenu::get_menu_html("examples.html"), 'okapi_base_url' => Settings::get('SITE_URL') . "okapi/", 'site_url' => Settings::get('SITE_URL'), 'installations' => OkapiMenu::get_installations(), 'okapi_rev' => Okapi::$version_number, 'site_name' => Okapi::get_normalized_site_name());
$response = new OkapiHttpResponse();
$response->content_type = "text/html; charset=utf-8";
ob_start();
include 'examples.tpl.php';
$response->body = ob_get_clean();
return $response;
}
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()
{
require_once $GLOBALS['rootpath'] . 'okapi/views/menu.inc.php';
require_once $GLOBALS['rootpath'] . 'okapi/views/changelog_helper.inc.php';
$changelog = new Changelog();
$vars = array('menu' => OkapiMenu::get_menu_html("changelog.html"), 'okapi_base_url' => Settings::get('SITE_URL') . "okapi/", 'site_url' => Settings::get('SITE_URL'), 'installations' => OkapiMenu::get_installations(), 'okapi_rev' => Okapi::$version_number, 'site_name' => Okapi::get_normalized_site_name(), 'changes' => array('unavailable' => $changelog->unavailable_changes, 'available' => $changelog->available_changes));
$response = new OkapiHttpResponse();
$response->content_type = "text/html; charset=utf-8";
ob_start();
include 'changelog.tpl.php';
$response->body = ob_get_clean();
return $response;
}
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 dispatch_request($uri)
{
# Chop off the ?args=... part.
if (strpos($uri, '?') !== false) {
$uri = substr($uri, 0, strpos($uri, '?'));
}
# Chop off everything before "/okapi/". This should work for okay for most "weird"
# server configurations. It will also address a more subtle issue described here:
# http://stackoverflow.com/questions/8040461/request-uri-unexpectedly-contains-fqdn
if (strpos($uri, "/okapi/") !== false) {
$uri = substr($uri, strpos($uri, "/okapi/"));
}
# Make sure we're in the right directory (.htaccess should make sure of that).
if (strpos($uri, "/okapi/") !== 0) {
throw new Exception("'{$uri}' is outside of the /okapi/ path.");
}
$uri = substr($uri, 7);
# Initializing internals and running pre-request cronjobs (we don't want
# cronjobs to be run before "okapi/update", for example before database
# was installed).
$allow_cronjobs = $uri != "update";
Okapi::init_internals($allow_cronjobs);
# Checking for allowed patterns...
try {
foreach (OkapiUrls::$mapping as $pattern => $namespace) {
$matches = null;
if (preg_match("#{$pattern}#", $uri, $matches)) {
# Pattern matched! Moving on to the proper View...
array_shift($matches);
require_once $GLOBALS['rootpath'] . "okapi/views/{$namespace}.php";
$response = call_user_func_array(array('\\okapi\\views\\' . str_replace('/', '\\', $namespace) . '\\View', 'call'), $matches);
if ($response) {
$response->display();
}
return;
}
}
} catch (Http404 $e) {
/* pass */
}
# None of the patterns matched OR method threw the Http404 exception.
require_once $GLOBALS['rootpath'] . "okapi/views/http404.php";
$response = \okapi\views\http404\View::call();
$response->display();
}
public static function call()
{
if (isset($_REQUEST['posted'])) {
$appname = isset($_REQUEST['appname']) ? $_REQUEST['appname'] : "";
$appname = trim($appname);
$appurl = isset($_REQUEST['appurl']) ? $_REQUEST['appurl'] : "";
$email = isset($_REQUEST['email']) ? $_REQUEST['email'] : "";
$accepted_terms = isset($_REQUEST['terms']) ? $_REQUEST['terms'] : "";
$ok = false;
if (!$appname) {
$notice = "Please provide a valid application name.";
} elseif (mb_strlen($appname) > 100) {
$notice = "Application name should be less than 100 characters long.";
} elseif (mb_strlen($appurl) > 250) {
$notice = "Application URL should be less than 250 characters long.";
} elseif ($appurl && substr($appurl, 0, 7) != "http://" && substr($appurl, 0, 8) != "https://") {
$notice = "Application homepage URL should start with http(s)://. (Note: this URL is OPTIONAL and it is NOT for OAuth callback.)";
} elseif (!$email) {
$notice = "Please provide a valid email address.";
} elseif (mb_strlen($email) > 70) {
$notice = "Email address should be less than 70 characters long.";
} elseif (!$accepted_terms) {
$notice = "You have to read and accept OKAPI Terms of Use.";
} else {
$ok = true;
Okapi::register_new_consumer($appname, $appurl, $email);
$notice = "Consumer Key generated successfully.\nCheck your email!";
}
$response = new OkapiHttpResponse();
$response->content_type = "application/json; charset=utf-8";
$response->body = json_encode(array('ok' => $ok, 'notice' => $notice));
return $response;
}
require_once $GLOBALS['rootpath'] . 'okapi/service_runner.php';
require_once $GLOBALS['rootpath'] . 'okapi/views/menu.inc.php';
$vars = array('menu' => OkapiMenu::get_menu_html("signup.html"), 'okapi_base_url' => Settings::get('SITE_URL') . "okapi/", 'site_url' => Settings::get('SITE_URL'), 'site_name' => Okapi::get_normalized_site_name(), 'installations' => OkapiMenu::get_installations(), 'okapi_rev' => Okapi::$version_number, 'data_license_html' => Settings::get('DATA_LICENSE_URL') ? "<a href='" . Settings::get('DATA_LICENSE_URL') . "'>Data License</a>" : "Data License");
$response = new OkapiHttpResponse();
$response->content_type = "text/html; charset=utf-8";
ob_start();
include 'signup.tpl.php';
$response->body = ob_get_clean();
return $response;
}
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)
{
# "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);
}
