/**
* Magic __set_state helps to re-build messages variable exporting
*
* @param array $message
* @return Phalcon\Mvc\Collection\Message
*/
PHP_METHOD(Phalcon_Mvc_Collection_Message, __set_state){
zval *message, *message_text, *field, *type, *code;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &message);
PHALCON_OBS_VAR(message_text);
phalcon_array_fetch_str(&message_text, message, SL("_message"), PH_NOISY);
PHALCON_OBS_VAR(field);
phalcon_array_fetch_str(&field, message, SL("_field"), PH_NOISY);
PHALCON_OBS_VAR(type);
phalcon_array_fetch_str(&type, message, SL("_type"), PH_NOISY);
PHALCON_OBS_VAR(code);
phalcon_array_fetch_str(&code, message, SL("_code"), PH_NOISY);
object_init_ex(return_value, phalcon_mvc_collection_message_ce);
PHALCON_CALL_METHOD(NULL, return_value, "__construct", message_text, field, type, code);
RETURN_MM();
}
/**
* Magic __set_state helps to recover messsages from serialization
*
* @param array $message
* @return Phalcon\Validation\Message
*/
PHP_METHOD(Phalcon_Validation_Message, __set_state){
zval *message, message_text = {}, field = {}, type = {}, code = {};
phalcon_fetch_params(0, 1, 0, &message);
phalcon_array_fetch_str(&message_text, message, SL("_message"), PH_NOISY);
phalcon_array_fetch_str(&field, message, SL("_field"), PH_NOISY);
phalcon_array_fetch_str(&type, message, SL("_type"), PH_NOISY);
phalcon_array_fetch_str(&code, message, SL("_code"), PH_NOISY);
object_init_ex(return_value, phalcon_validation_message_ce);
PHALCON_CALL_METHODW(NULL, return_value, "__construct", &message_text, &field, &type, &code);
}
/**
* Generates SQL to create a view
*
* @param string $viewName
* @param array $definition
* @param string $schemaName
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect_Sqlite, createView){
zval *view_name, *definition, *schema_name, *view_sql;
zval *view = NULL, *sql;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 3, 0, &view_name, &definition, &schema_name);
if (!phalcon_array_isset_str(definition, SL("sql"))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The index 'sql' is required in the definition array");
return;
}
PHALCON_OBS_VAR(view_sql);
phalcon_array_fetch_str(&view_sql, definition, SL("sql"), PH_NOISY);
if (zend_is_true(schema_name)) {
PHALCON_INIT_VAR(view);
PHALCON_CONCAT_VSV(view, schema_name, "\".\"", view_name);
} else {
PHALCON_CPY_WRT(view, view_name);
}
PHALCON_INIT_VAR(sql);
PHALCON_CONCAT_SVSV(sql, "CREATE VIEW \"", view, "\" AS ", view_sql);
RETURN_CTOR(sql);
}
/**
* Draws a polygon
*
*<code>
* $coordinates = array( array( 'x' => 4, 'y' => 6 ), array( 'x' => 8, 'y' => 10 ) );
* $image->polygon($coordinates);
*</code>
*
* @param array $coordinates array of x and y
* @param string $color
* @return Phalcon\Image\Adapter\GD
*/
PHP_METHOD(Phalcon_Image_Adapter_GD, polygon){
zval *coordinates, *color = NULL, image = {}, rgb = {}, r = {}, g = {}, b = {}, imagecolor = {}, *point, points = {}, num_points = {};
phalcon_fetch_params(0, 1, 1, &coordinates, &color);
if (!color) {
color = &PHALCON_GLOBAL(z_null);
}
if (!phalcon_fast_count_ev(coordinates)) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_image_exception_ce, "Coordinates must be not empty");
return;
}
phalcon_return_property(&image, getThis(), SL("_image"));
if (Z_TYPE(image) == IS_RESOURCE) {
PHALCON_CALL_METHODW(&rgb, getThis(), "getcolorrbg", color);
phalcon_array_fetch_long(&r, &rgb, 0, PH_NOISY);
phalcon_array_fetch_long(&g, &rgb, 1, PH_NOISY);
phalcon_array_fetch_long(&b, &rgb, 2, PH_NOISY);
PHALCON_CALL_FUNCTIONW(&imagecolor, "imagecolorallocate", &image, &r, &g, &b);
array_init(&points);
ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(coordinates), point) {
zval x = {}, y = {};
if (Z_TYPE_P(point) == IS_ARRAY) {
if (phalcon_fast_count_int(point) != 2) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_image_exception_ce, "Coordinates point error");
return;
}
if (!phalcon_array_isset_fetch_long(&x, point, 0)) {
phalcon_array_fetch_str(&x, point, SL("x"), PH_NOISY);
}
if (!phalcon_array_isset_fetch_long(&y, point, 0)) {
phalcon_array_fetch_str(&y, point, SL("y"), PH_NOISY);
}
phalcon_array_append(&points, &x, PH_COPY);
phalcon_array_append(&points, &y, PH_COPY);
} else {
phalcon_array_append(&points, &_p->val, PH_COPY);
_p++;
phalcon_array_append(&points, &_p->val, PH_COPY);
}
phalcon_increment(&num_points);
} ZEND_HASH_FOREACH_END();
/**
* Phalcon\Logger\Adapter\Syslog constructor
*
* @param string $name
* @param array $options
*/
PHP_METHOD(Phalcon_Logger_Adapter_Syslog, __construct){
zval *name, *options = NULL, *option = NULL, *facility = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &name, &options);
if (!options) {
options = &PHALCON_GLOBAL(z_null);
}
/**
* We use 'fopen' to respect to open-basedir directive
*/
if (zend_is_true(name)) {
if (phalcon_array_isset_str(options, SL("option"))) {
PHALCON_OBS_VAR(option);
phalcon_array_fetch_str(&option, options, SL("option"), PH_NOISY);
} else {
/**
* Open the log in LOG_ODELAY mode
*/
PHALCON_INIT_NVAR(option);
ZVAL_LONG(option, 4);
}
if (phalcon_array_isset_str(options, SL("facility"))) {
PHALCON_OBS_VAR(facility);
phalcon_array_fetch_str(&facility, options, SL("facility"), PH_NOISY);
} else {
/**
* By default the facility is LOG_USER
*/
PHALCON_INIT_NVAR(facility);
ZVAL_LONG(facility, 8);
}
PHALCON_CALL_FUNCTION(NULL, "openlog", name, option, facility);
phalcon_update_property_bool(getThis(), SL("_opened"), 1);
}
PHALCON_MM_RESTORE();
}
/**
* Gets most possible client IPv4 Address. This method search in $_SERVER['REMOTE_ADDR'] and optionally in $_SERVER['HTTP_X_FORWARDED_FOR']
*
* @param boolean $trustForwardedHeader
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, getClientAddress){
zval *trust_forwarded_header = NULL, *_SERVER, address = {}, addresses = {}, first = {};
phalcon_fetch_params(0, 0, 1, &trust_forwarded_header);
if (!trust_forwarded_header) {
trust_forwarded_header = &PHALCON_GLOBAL(z_false);
}
_SERVER = phalcon_get_global_str(SL("_SERVER"));
/**
* Proxies use this IP
*/
if (zend_is_true(trust_forwarded_header)) {
if (!phalcon_array_isset_fetch_str(&address, _SERVER, SL("HTTP_X_FORWARDED_FOR"))) {
if (!phalcon_array_isset_fetch_str(&address, _SERVER, SL("REMOTE_ADDR"))) {
phalcon_array_fetch_str(&address, _SERVER, SL("REMOTE_ADDR"), PH_NOISY);
}
}
} else if (!phalcon_array_isset_fetch_str(&address, _SERVER, SL("REMOTE_ADDR"))) {
phalcon_array_fetch_str(&address, _SERVER, SL("REMOTE_ADDR"), PH_NOISY);
}
if (Z_TYPE(address) == IS_STRING) {
if (phalcon_memnstr_str(&address, SL(","))) {
/**
* The client address has multiples parts, only return the first part
*/
phalcon_fast_explode_str(&addresses, SL(","), &address);
phalcon_array_fetch_long(&first, &addresses, 0, PH_NOISY);
RETURN_CTORW(&first);
}
RETURN_CTORW(&address);
}
RETURN_FALSE;
}
/**
* Reads the cookie-related info from the SESSION to restore the cookie as it was set
* This method is automatically called internally so normally you don't need to call it
*
* @return Phalcon\Http\Cookie
*/
PHP_METHOD(Phalcon_Http_Cookie, restore){
zval *restored, *dependency_injector, *service;
zval *session = NULL, *name, *key, *definition = NULL, *expire, *domain;
zval *path, *secure, *http_only;
PHALCON_MM_GROW();
restored = phalcon_read_property(getThis(), SL("_restored"), PH_NOISY);
if (!zend_is_true(restored)) {
dependency_injector = phalcon_read_property(getThis(), SL("_dependencyInjector"), PH_NOISY);
if (Z_TYPE_P(dependency_injector) == IS_OBJECT) {
PHALCON_INIT_VAR(service);
ZVAL_STR(service, IS(session));
PHALCON_CALL_METHOD(&session, dependency_injector, "getshared", service);
PHALCON_VERIFY_INTERFACE(session, phalcon_session_adapterinterface_ce);
name = phalcon_read_property(getThis(), SL("_name"), PH_NOISY);
PHALCON_INIT_VAR(key);
PHALCON_CONCAT_SV(key, "_PHCOOKIE_", name);
PHALCON_CALL_METHOD(&definition, session, "get", key);
if (Z_TYPE_P(definition) == IS_ARRAY) {
if (phalcon_array_isset_str(definition, SL("expire"))) {
PHALCON_OBS_VAR(expire);
phalcon_array_fetch_str(&expire, definition, SL("expire"), PH_NOISY);
phalcon_update_property_this(getThis(), SL("_expire"), expire);
}
if (phalcon_array_isset_str(definition, SL("domain"))) {
PHALCON_OBS_VAR(domain);
phalcon_array_fetch_str(&domain, definition, SL("domain"), PH_NOISY);
phalcon_update_property_this(getThis(), SL("_domain"), domain);
}
if (phalcon_array_isset_str(definition, SL("path"))) {
PHALCON_OBS_VAR(path);
phalcon_array_fetch_str(&path, definition, SL("path"), PH_NOISY);
phalcon_update_property_this(getThis(), SL("_path"), path);
}
if (phalcon_array_isset_str(definition, SL("secure"))) {
PHALCON_OBS_VAR(secure);
phalcon_array_fetch_str(&secure, definition, SL("secure"), PH_NOISY);
phalcon_update_property_this(getThis(), SL("_secure"), secure);
}
if (phalcon_array_isset_str(definition, SL("httpOnly"))) {
PHALCON_OBS_VAR(http_only);
phalcon_array_fetch_str(&http_only, definition, SL("httpOnly"), PH_NOISY);
phalcon_update_property_this(getThis(), SL("_httpOnly"), http_only);
}
}
}
phalcon_update_property_bool(getThis(), SL("_restored"), 1);
}
RETURN_THIS();
}
/**
* Returns a slice of the resultset to show in the pagination
*
* @return \stdClass
*/
PHP_METHOD(Phalcon_Paginator_Adapter_Model, getPaginate) {
zval show = {}, config = {}, items = {}, page_number = {}, rowcount = {}, page = {}, last_show_page = {}, start = {}, possible_pages = {}, total_pages = {};
zval page_items = {}, maximum_pages = {}, next = {}, additional_page = {}, before = {}, remainder = {}, pages_total = {};
long int i, i_show;
phalcon_return_property(&show, getThis(), SL("_limitRows"));
phalcon_return_property(&config, getThis(), SL("_config"));
phalcon_return_property(&page_number, getThis(), SL("_page"));
i_show = phalcon_get_intval(&show);
phalcon_array_fetch_str(&items, &config, SL("data"), PH_NOISY);
if (Z_TYPE(page_number) == IS_NULL || PHALCON_LT(&show, &PHALCON_GLOBAL(z_zero))) {
PHALCON_CPY_WRT_CTOR(&page_number, &PHALCON_GLOBAL(z_one));
}
phalcon_fast_count(&rowcount, &items);
object_init(&page);
phalcon_sub_function(&last_show_page, &page_number, &PHALCON_GLOBAL(z_one));
mul_function(&start, &show, &last_show_page);
phalcon_div_function(&possible_pages, &rowcount, &show);
if (unlikely(Z_TYPE(possible_pages)) != IS_DOUBLE) {
convert_to_double(&possible_pages);
}
ZVAL_LONG(&total_pages, (long int)ceil(Z_DVAL(possible_pages)));
if (Z_TYPE(items) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_paginator_exception_ce, "Invalid data for paginator");
return;
}
array_init(&page_items);
if (PHALCON_GT(&rowcount, &PHALCON_GLOBAL(z_zero))) {
/**
* Seek to the desired position
*/
if (PHALCON_LT(&start, &rowcount)) {
PHALCON_CALL_METHODW(NULL, &items, "seek", &start);
} else {
PHALCON_CALL_METHODW(NULL, &items, "rewind");
PHALCON_CPY_WRT_CTOR(&page_number, &PHALCON_GLOBAL(z_one));
PHALCON_CPY_WRT_CTOR(&start, &PHALCON_GLOBAL(z_zero));
}
/**
* The record must be iterable
*/
for (i=1; ; ++i) {
zval valid = {}, current = {};
PHALCON_CALL_METHODW(&valid, &items, "valid");
if (!PHALCON_IS_NOT_FALSE(&valid)) {
break;
}
PHALCON_CALL_METHODW(¤t, &items, "current");
phalcon_array_append(&page_items, ¤t, PH_COPY);
if (i >= i_show) {
break;
}
}
}
phalcon_update_property_zval(&page, SL("items"), &page_items);
phalcon_add_function(&maximum_pages, &start, &show);
if (PHALCON_LT(&maximum_pages, &rowcount)) {
phalcon_add_function(&next, &page_number, &PHALCON_GLOBAL(z_one));
} else if (PHALCON_IS_EQUAL(&maximum_pages, &rowcount)) {
PHALCON_CPY_WRT_CTOR(&next, &rowcount);
} else {
phalcon_div_function(&possible_pages, &rowcount, &show);
phalcon_add_function(&additional_page, &possible_pages, &PHALCON_GLOBAL(z_one));
ZVAL_LONG(&next, phalcon_get_intval(&additional_page));
}
if (PHALCON_GT(&next, &total_pages)) {
PHALCON_CPY_WRT_CTOR(&next, &total_pages);
}
phalcon_update_property_zval(&page, SL("next"), &next);
if (PHALCON_GT(&page_number, &PHALCON_GLOBAL(z_one))) {
phalcon_sub_function(&before, &page_number, &PHALCON_GLOBAL(z_one));
} else {
PHALCON_CPY_WRT_CTOR(&before, &PHALCON_GLOBAL(z_one));
}
phalcon_update_property_zval(&page, SL("first"), &PHALCON_GLOBAL(z_one));
phalcon_update_property_zval(&page, SL("before"), &before);
phalcon_update_property_zval(&page, SL("current"), &page_number);
mod_function(&remainder, &rowcount, &show);
phalcon_div_function(&possible_pages, &rowcount, &show);
if (!PHALCON_IS_LONG(&remainder, 0)) {
phalcon_add_function(&next, &possible_pages, &PHALCON_GLOBAL(z_one));
ZVAL_LONG(&pages_total, phalcon_get_intval(&next));
} else {
PHALCON_CPY_WRT_CTOR(&pages_total, &possible_pages);
}
phalcon_update_property_zval(&page, SL("last"), &pages_total);
phalcon_update_property_zval(&page, SL("total_pages"), &pages_total);
phalcon_update_property_zval(&page, SL("total_items"), &rowcount);
RETURN_CTORW(&page);
}
/**
* Handles a MVC request
*
* @param string $uri
* @return Phalcon\Http\ResponseInterface
*/
PHP_METHOD(Phalcon_Mvc_JsonRpc, handle){
zval *uri = NULL, *dependency_injector, *events_manager;
zval *status = NULL, *service = NULL, *request = NULL, *response = NULL;
zval *json = NULL, *data = NULL, *jsonrpc_message, *jsonrpc_error, *jsonrpc_result = NULL;
zval *jsonrpc_method, *jsonrpc_params, *jsonrpc_id;
zval *url = NULL, *router = NULL, *module_name = NULL;
zval *module_object = NULL, *modules;
zval *module, *class_name = NULL, *module_params;
zval *namespace_name = NULL;
zval *controller_name = NULL, *action_name = NULL, *params = NULL, *exact = NULL;
zval *dispatcher = NULL, *controller = NULL, *returned_response = NULL;
zval *path;
PHALCON_MM_GROW();
dependency_injector = phalcon_read_property(getThis(), SL("_dependencyInjector"), PH_NOISY);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_jsonrpc_exception_ce, "A dependency injection object is required to access internal services");
return;
}
events_manager = phalcon_read_property(getThis(), SL("_eventsManager"), PH_NOISY);
if (Z_TYPE_P(events_manager) != IS_OBJECT) {
events_manager = NULL;
}
else {
PHALCON_VERIFY_INTERFACE_EX(events_manager, phalcon_events_managerinterface_ce, phalcon_mvc_jsonrpc_exception_ce, 1);
}
/* Call boot event, this allows the developer to perform initialization actions */
if (FAILURE == phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:boot", getThis(), NULL)) {
RETURN_MM_FALSE;
}
/* Deserializer Json */
PHALCON_INIT_NVAR(service);
ZVAL_STR(service, IS(request));
PHALCON_CALL_METHOD(&request, dependency_injector, "getshared", service);
PHALCON_VERIFY_INTERFACE(request, phalcon_http_requestinterface_ce);
PHALCON_CALL_METHOD(&json, request, "getrawbody");
PHALCON_CALL_FUNCTION(&data, "json_decode", json, &PHALCON_GLOBAL(z_true));
PHALCON_INIT_NVAR(service);
ZVAL_STR(service, IS(response));
PHALCON_CALL_METHOD(&response, dependency_injector, "getshared", service);
PHALCON_VERIFY_INTERFACE(response, phalcon_http_responseinterface_ce);
PHALCON_INIT_VAR(jsonrpc_message);
array_init(jsonrpc_message);
PHALCON_INIT_VAR(jsonrpc_error);
array_init(jsonrpc_error);
if (PHALCON_IS_EMPTY(data)) {
phalcon_array_update_str_long(jsonrpc_error, SL("code"), __LINE__, 0);
phalcon_array_update_str_str(jsonrpc_error, SL("message"), SL("Parse error"), PH_COPY);
} else if (Z_TYPE_P(data) != IS_ARRAY) {
phalcon_array_update_str_long(jsonrpc_error, SL("code"), __LINE__, 0);
phalcon_array_update_str_str(jsonrpc_error, SL("message"), SL("Parse error"), PH_COPY);
} else if (!phalcon_array_isset_str(data, SL("jsonrpc"))) {
phalcon_array_update_str_long(jsonrpc_error, SL("code"), __LINE__, 0);
phalcon_array_update_str_str(jsonrpc_error, SL("message"), SL("Invalid Request"), PH_COPY);
} else if (!phalcon_array_isset_str(data, SL("method"))) {
phalcon_array_update_str_long(jsonrpc_error, SL("code"), __LINE__, 0);
phalcon_array_update_str_str(jsonrpc_error, SL("message"), SL("Invalid Request"), PH_COPY);
} else {
PHALCON_OBS_VAR(jsonrpc_method);
phalcon_array_fetch_str(&jsonrpc_method, data, SL("method"), PH_NOISY);
if (phalcon_array_isset_str(data, SL("params"))) {
PHALCON_OBS_VAR(jsonrpc_params);
phalcon_array_fetch_str(&jsonrpc_params, data, SL("params"), PH_NOISY);
} else {
PHALCON_INIT_VAR(jsonrpc_params);
array_init(jsonrpc_params);
}
PHALCON_INIT_NVAR(service);
ZVAL_STR(service, IS(url));
PHALCON_CALL_METHOD(&url, dependency_injector, "getshared", service);
PHALCON_VERIFY_INTERFACE(url, phalcon_mvc_urlinterface_ce);
PHALCON_CALL_METHOD(&uri, url, "get", jsonrpc_method);
PHALCON_INIT_NVAR(service);
ZVAL_STR(service, IS(router));
PHALCON_CALL_METHOD(&router, dependency_injector, "getshared", service);
PHALCON_VERIFY_INTERFACE(router, phalcon_mvc_routerinterface_ce);
/* Handle the URI pattern (if any) */
PHALCON_CALL_METHOD(NULL, router, "handle", uri);
/* Load module config */
PHALCON_CALL_METHOD(&module_name, router, "getmodulename");
/* Load module config */
PHALCON_CALL_METHOD(&module_name, router, "getmodulename");
/* If the router doesn't return a valid module we use the default module */
if (!zend_is_true(module_name)) {
module_name = phalcon_read_property(getThis(), SL("_defaultModule"), PH_NOISY);
}
/**
* Process the module definition
*/
if (zend_is_true(module_name)) {
if (FAILURE == phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:beforeStartModule", getThis(), module_name)) {
RETURN_MM_FALSE;
}
/**
* Check if the module passed by the router is registered in the modules container
*/
modules = phalcon_read_property(getThis(), SL("_modules"), PH_NOISY);
if (!phalcon_array_isset_fetch(&module, modules, module_name)) {
convert_to_string(module_name);
zend_throw_exception_ex(phalcon_mvc_jsonrpc_exception_ce, 0, "Module %s is not registered in the jsonrpc container", Z_STRVAL_P(module_name));
RETURN_MM();
}
/**
* A module definition must be an array or an object
*/
if (Z_TYPE_P(module) != IS_ARRAY && Z_TYPE_P(module) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_jsonrpc_exception_ce, "Invalid module definition");
return;
}
/* An array module definition contains a path to a module definition class */
if (Z_TYPE_P(module) == IS_ARRAY) {
/* Class name used to load the module definition */
if (phalcon_array_isset_str(module, SL("className"))) {
PHALCON_OBS_VAR(class_name);
phalcon_array_fetch_str(&class_name, module, SL("className"), PH_NOISY);
} else {
PHALCON_INIT_NVAR(class_name);
ZVAL_STRING(class_name, "Module");
}
/* If the developer has specified a path, try to include the file */
if (phalcon_array_isset_str(module, SL("path"))) {
PHALCON_OBS_VAR(path);
phalcon_array_fetch_str(&path, module, SL("path"), PH_NOISY);
convert_to_string_ex(path);
if (Z_TYPE_P(class_name) != IS_STRING || phalcon_class_exists(class_name, 0) == NULL) {
if (phalcon_file_exists(path) == SUCCESS) {
RETURN_MM_ON_FAILURE(phalcon_require(Z_STRVAL_P(path)));
} else {
zend_throw_exception_ex(phalcon_mvc_jsonrpc_exception_ce, 0, "Module definition path '%s' does not exist", Z_STRVAL_P(path));
RETURN_MM();
}
}
}
PHALCON_CALL_METHOD(&module_object, dependency_injector, "get", class_name);
/**
* 'registerAutoloaders' and 'registerServices' are automatically called
*/
PHALCON_CALL_METHOD(NULL, module_object, "registerautoloaders", dependency_injector);
PHALCON_CALL_METHOD(NULL, module_object, "registerservices", dependency_injector);
} else if (Z_TYPE_P(module) == IS_OBJECT && instanceof_function(Z_OBJCE_P(module), zend_ce_closure)) {
/* A module definition object, can be a Closure instance */
PHALCON_INIT_VAR(module_params);
array_init_size(module_params, 1);
phalcon_array_append(module_params, dependency_injector, PH_COPY);
PHALCON_CALL_USER_FUNC_ARRAY(&status, module, module_params);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_jsonrpc_exception_ce, "Invalid module definition");
return;
}
/* Calling afterStartModule event */
if (events_manager) {
if (!module_object) {
module_object = &PHALCON_GLOBAL(z_null);
}
phalcon_update_property_this(getThis(), SL("_moduleObject"), module_object);
if (FAILURE == phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:afterStartModule", getThis(), module_name)) {
RETURN_MM_FALSE;
}
}
}
/* We get the parameters from the router and assign them to the dispatcher */
PHALCON_CALL_METHOD(&module_name, router, "getmodulename");
PHALCON_CALL_METHOD(&namespace_name, router, "getnamespacename");
PHALCON_CALL_METHOD(&controller_name, router, "getcontrollername");
PHALCON_CALL_METHOD(&action_name, router, "getactionname");
PHALCON_CALL_METHOD(¶ms, router, "getparams");
PHALCON_CALL_METHOD(&exact, router, "isexactcontrollername");
PHALCON_INIT_NVAR(service);
ZVAL_STR(service, IS(dispatcher));
PHALCON_CALL_METHOD(&dispatcher, dependency_injector, "getshared", service);
PHALCON_VERIFY_INTERFACE(dispatcher, phalcon_dispatcherinterface_ce);
/* Assign the values passed from the router */
PHALCON_CALL_METHOD(NULL, dispatcher, "setmodulename", module_name);
PHALCON_CALL_METHOD(NULL, dispatcher, "setnamespacename", namespace_name);
PHALCON_CALL_METHOD(NULL, dispatcher, "setcontrollername", controller_name, exact);
PHALCON_CALL_METHOD(NULL, dispatcher, "setactionname", action_name);
PHALCON_CALL_METHOD(NULL, dispatcher, "setparams", jsonrpc_params);
/* Calling beforeHandleRequest */
RETURN_MM_ON_FAILURE(phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:beforeHandleRequest", getThis(), dispatcher));
/* The dispatcher must return an object */
PHALCON_CALL_METHOD(&controller, dispatcher, "dispatch");
PHALCON_INIT_VAR(returned_response);
/* Get the latest value returned by an action */
PHALCON_CALL_METHOD(&jsonrpc_result, dispatcher, "getreturnedvalue");
}
/* Calling afterHandleRequest */
if (FAILURE == phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:afterHandleRequest", getThis(), controller) && EG(exception)) {
RETURN_MM();
}
phalcon_array_update_str_str(jsonrpc_message, SL("jsonrpc"), SL("2.0"), PH_COPY);
if (PHALCON_IS_NOT_EMPTY(jsonrpc_error)) {
phalcon_array_update_str(jsonrpc_message, SL("error"), jsonrpc_error, PH_COPY);
}
if (jsonrpc_result != NULL) {
phalcon_array_update_str(jsonrpc_message, SL("result"), jsonrpc_result, PH_COPY);
}
if (phalcon_array_isset_str_fetch(&jsonrpc_id, data, SL("id"))) {
phalcon_array_update_str(jsonrpc_message, SL("id"), jsonrpc_id, PH_COPY);
} else {
phalcon_array_update_str(jsonrpc_message, SL("id"), &PHALCON_GLOBAL(z_null), PH_COPY);
}
PHALCON_CALL_METHOD(NULL, response, "setjsoncontent", jsonrpc_message);
/* Calling beforeSendResponse */
if (FAILURE == phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:beforeSendResponse", getThis(), response) && EG(exception)) {
RETURN_MM();
}
/* Headers are automatically sent */
PHALCON_CALL_METHOD(NULL, response, "sendheaders");
/* Cookies are automatically sent */
PHALCON_CALL_METHOD(NULL, response, "sendcookies");
/* Return the response */
RETURN_CCTOR(response);
}
/**
* Gets number of rows returned by a resulset
*
*<code>
* $result = $connection->query("SELECT * FROM robots ORDER BY name");
* echo 'There are ', $result->numRows(), ' rows in the resulset';
*</code>
*
* @return int
*/
PHP_METHOD(Phalcon_Db_Result_Pdo, numRows){
zval *row_count = NULL, *connection, *type = NULL, *pdo_statement = NULL;
zval *sql_statement, *bind_params, *bind_types;
zval *matches, *pattern, *match, *else_clauses;
zval *sql, *result = NULL, *row = NULL;
PHALCON_MM_GROW();
row_count = phalcon_read_property(getThis(), SL("_rowCount"), PH_NOISY);
if (PHALCON_IS_FALSE(row_count)) {
connection = phalcon_read_property(getThis(), SL("_connection"), PH_NOISY);
PHALCON_CALL_METHOD(&type, connection, "gettype");
/**
* MySQL/PostgreSQL library property returns the number of records
*/
if (PHALCON_IS_STRING(type, "mysql") || PHALCON_IS_STRING(type, "pgsql")) {
pdo_statement = phalcon_read_property(getThis(), SL("_pdoStatement"), PH_NOISY);
PHALCON_CALL_METHOD(&row_count, pdo_statement, "rowcount");
}
/**
* We should get the count using a new statement :(
*/
if (PHALCON_IS_FALSE(row_count)) {
/**
* SQLite/Oracle/SQLServer returns resultsets that to the client eyes (PDO) has an
* arbitrary number of rows, so we need to perform an extra count to know that
*/
sql_statement = phalcon_read_property(getThis(), SL("_sqlStatement"), PH_NOISY);
/**
* If the sql_statement starts with SELECT COUNT(*) we don't make the count
*/
if (!phalcon_start_with_str(sql_statement, SL("SELECT COUNT(*) "))) {
bind_params = phalcon_read_property(getThis(), SL("_bindParams"), PH_NOISY);
bind_types = phalcon_read_property(getThis(), SL("_bindTypes"), PH_NOISY);
PHALCON_INIT_VAR(matches);
PHALCON_INIT_VAR(pattern);
ZVAL_STRING(pattern, "/^SELECT\\s+(.*)$/i");
PHALCON_INIT_VAR(match);
RETURN_MM_ON_FAILURE(phalcon_preg_match(match, pattern, sql_statement, matches));
if (zend_is_true(match)) {
PHALCON_OBS_VAR(else_clauses);
phalcon_array_fetch_long(&else_clauses, matches, 1, PH_NOISY);
PHALCON_INIT_VAR(sql);
PHALCON_CONCAT_SVS(sql, "SELECT COUNT(*) \"numrows\" FROM (SELECT ", else_clauses, ")");
PHALCON_CALL_METHOD(&result, connection, "query", sql, bind_params, bind_types);
PHALCON_CALL_METHOD(&row, result, "fetch");
PHALCON_OBS_NVAR(row_count);
phalcon_array_fetch_str(&row_count, row, SL("numrows"), PH_NOISY);
}
} else {
PHALCON_INIT_NVAR(row_count);
ZVAL_LONG(row_count, 1);
}
}
/**
* Update the value to avoid further calculations
*/
phalcon_update_property_this(getThis(), SL("_rowCount"), row_count);
}
RETURN_CCTOR(row_count);
}
