public function handle($instance, $serverKey, $parameters, $httpRequestMethod)
{
// Validate HTTP Verb
if (strtolower($httpRequestMethod) != "get") {
throw new MashapeException(EXCEPTION_INVALID_HTTPMETHOD, EXCEPTION_INVALID_HTTPMETHOD_CODE);
}
// Validate request
if ($this->validateRequest($serverKey) == false) {
throw new MashapeException(EXCEPTION_AUTH_INVALID_SERVERKEY, EXCEPTION_AUTH_INVALID_SERVERKEY_CODE);
}
$resultXml = "<?xml version=\"1.0\" ?>\n";
$fileParts = Explode('/', $_SERVER["PHP_SELF"]);
$scriptName = $fileParts[count($fileParts) - 1];
$baseUrl = Explode("/" . $scriptName, $this->curPageURL());
$resultXml .= "<api baseUrl=\"" . $baseUrl[0] . "\" " . $this->getSimpleInfo() . ">\n";
$mode = isset($parameters[MODE]) ? $parameters[MODE] : null;
$configuration = RESTConfigurationLoader::reloadConfiguration($serverKey);
if ($mode == null || $mode != SIMPLE_MODE) {
$objectsFound = array();
$objectsToCreate = array();
$methods = discoverMethods($instance, $configuration, $objectsFound, $objectsToCreate, $scriptName);
$objects = discoverObjects($configuration, $objectsFound);
$resultXml .= $methods . $objects . generateObjects($objectsToCreate);
// Update the .htaccess file with the new route settings
updateHtaccess($instance);
}
$resultXml .= "</api>";
return $resultXml;
}
function testLoadConfiguration()
{
$serverKey = "the-server-key";
$configuration = RESTConfigurationLoader::loadConfiguration($serverKey);
$this->assertFalse($configuration == null);
$this->assertEquals(1, count($configuration->getMethods()));
$this->assertEquals(0, count($configuration->getObjects()));
}
private function reloadConfiguration($instance, $serverKey)
{
if (HttpUtils::isLocal()) {
// Update the .htaccess file with the new route settings
updateHtaccess($instance);
// Update the configuration
RESTConfigurationLoader::reloadConfiguration($serverKey);
}
}
function serializeObject($result, $instance, $isSimpleResult, $serverKey)
{
$json = "";
if ($isSimpleResult) {
// It's a simple result, just serialize it
$json = JsonUtils::encodeToJson($result);
} else {
// It's a custom object, let's serialize recursively every field
$className = get_class($result);
$reflectedClass = new ReflectionClass($className);
$xmlObject = RESTConfigurationLoader::getObject($className, $serverKey);
if (empty($xmlObject)) {
throw new MashapeException(sprintf(EXCEPTION_UNKNOWN_OBJECT, $className), EXCEPTION_GENERIC_LIBRARY_ERROR_CODE);
}
// Start element
$json .= "{";
// Serialize fields
$fields = $xmlObject->getFields();
for ($i = 0; $i < count($fields); $i++) {
$field = $fields[$i];
$fieldName = $field->getName();
$fieldMethod = $field->getMethod();
$fieldValue = null;
if (empty($fieldMethod)) {
if ($reflectedClass->hasProperty($fieldName)) {
$reflectedProperty = $reflectedClass->getProperty($fieldName);
if ($reflectedProperty->isPublic()) {
$fieldValue = $reflectedProperty->getValue($result);
} else {
// Try using the __get magic method
$fieldValue = $reflectedClass->getMethod("__get")->invokeArgs($result, array($fieldName));
}
} else {
if (ArrayUtils::existKey($fieldName, get_object_vars($result))) {
$fieldValue = $result->{$fieldName};
} else {
throw new MashapeException(sprintf(EXCEPTION_FIELD_NOTFOUND, $fieldName), EXCEPTION_GENERIC_LIBRARY_ERROR_CODE);
}
}
} else {
$fieldValue = $reflectedClass->getMethod($fieldMethod)->invoke($result);
}
if ($fieldValue === null && $field->isOptional()) {
// Don't serialize the field
continue;
}
$json .= '"' . $fieldName . '":';
if ($fieldValue === null) {
$json .= JsonUtils::encodeToJson($fieldValue);
} else {
$isSimpleField = isSimpleField($field);
if ($field->isArray()) {
if (is_array($fieldValue)) {
$json .= serializeArray($fieldValue, $instance, isSimpleField($field), $serverKey);
} else {
// The result it's not an array although it was described IT WAS an array
throw new MashapeException(sprintf(EXCEPTION_EXPECTED_ARRAY_RESULT, $fieldName, $className), EXCEPTION_GENERIC_LIBRARY_ERROR_CODE);
}
} else {
if (is_array($fieldValue)) {
// The result it's an array although it was described IT WAS NOT an array
throw new MashapeException(sprintf(EXCEPTION_UNEXPECTED_ARRAY_RESULT, $fieldName, $className), EXCEPTION_GENERIC_LIBRARY_ERROR_CODE);
} else {
$json .= serializeObject($fieldValue, $instance, $isSimpleField, $serverKey);
}
}
}
$json .= ",";
}
if (substr($json, strlen($json) - 1, 1) != "{") {
$json = JsonUtils::removeLastChar($fields, $json);
}
// Close element
$json .= "}";
}
return $json;
}
function testError()
{
RESTConfigurationLoader::reloadConfiguration(SERVER_KEY, dirname(__FILE__) . "/test7.xml");
$method = new RESTMethod();
$method->setName("touchError");
$method->setObject("ClassOne");
$method->setArray(true);
$this->assertEquals('[{"code":1,"message":"custom message"}]', doCall($method, null, new NewSampleAPI(), SERVER_KEY));
}
function findRoute($requestUri, &$routeParameters, $httpRequestMethod, $serverKey)
{
$routeMethod = null;
$configuration = RESTConfigurationLoader::loadConfiguration($serverKey);
$methods = $configuration->getMethods();
for ($i = 0; $i < count($methods); $i++) {
if ($methods[$i]->getHttp() != $httpRequestMethod) {
unset($methods[$i]);
}
}
$requestUri = Explode("?", substr($requestUri, 1));
$requestUriParts = Explode("/", $requestUri[0]);
$likelyMethods = array();
$excludedMethods = array();
// Backward loop
for ($i = count($requestUriParts) - 1; $i >= 0; $i--) {
// Find if there's a path like that, otherwise check for placeholders
foreach ($methods as $method) {
$methodName = $method->getName();
if (in_array($methodName, $excludedMethods)) {
continue;
}
$route = $method->getRoute();
if (!empty($route)) {
$routeParts = Explode("/", substr($route, 1));
if (count($routeParts) <= count($requestUriParts)) {
$backwardIndex = count($routeParts) - (count($requestUriParts) - $i);
if ($backwardIndex >= 0) {
if ($routeParts[$backwardIndex] == $requestUriParts[$i]) {
if (!ArrayUtils::existKey($methodName, $likelyMethods)) {
$likelyMethods[$methodName] = array();
}
} else {
if (RouteUtils::isRoutePlaceholder($routeParts[$backwardIndex])) {
$foundParameters;
$placeHolder = RouteUtils::getRoutePlaceholder($routeParts[$backwardIndex]);
if (!ArrayUtils::existKey($methodName, $likelyMethods)) {
$foundParameters = array();
} else {
$foundParameters = $likelyMethods[$methodName];
}
$foundParameters[$placeHolder] = $requestUriParts[$i];
$likelyMethods[$methodName] = $foundParameters;
} else {
array_push($excludedMethods, $methodName);
unset($likelyMethods[$methodName]);
}
}
}
}
}
}
}
if (count($likelyMethods) > 1) {
// Get the route with the highest matches
$maxRouteSize = 0;
foreach ($likelyMethods as $key => $value) {
$route = RESTConfigurationLoader::getMethod($key, $serverKey)->getRoute();
$routeSize = count(Explode("/", substr($route, 1)));
if ($routeSize > $maxRouteSize) {
$maxRouteSize = $routeSize;
}
}
foreach ($likelyMethods as $key => $value) {
$route = RESTConfigurationLoader::getMethod($key, $serverKey)->getRoute();
$routeSize = count(Explode("/", substr($route, 1)));
if ($routeSize < $maxRouteSize) {
unset($likelyMethods[$key]);
}
}
}
if (count($likelyMethods) > 1) {
$ambiguousMethods = "";
foreach ($likelyMethods as $key => $value) {
$ambiguousMethods .= "\"" . $key . "\", ";
}
$ambiguousMethods = substr($ambiguousMethods, 0, strlen($ambiguousMethods) - 2);
throw new MashapeException(sprintf(EXCEPTION_AMBIGUOUS_ROUTE, $ambiguousMethods), EXCEPTION_SYSTEM_ERROR_CODE);
}
// Get the first item (just one or none item can exist)
foreach ($likelyMethods as $key => $value) {
$routeMethod = RESTConfigurationLoader::getMethod($key, $serverKey);
$routeParameters = array_merge($routeParameters, $value);
break;
}
return $routeMethod;
}
