/** * Renders a partial view * * <code> * //Show a partial inside another view * $this->partial('shared/footer'); * </code> * * <code> * //Show a partial inside another view with parameters * $this->partial('shared/footer', array('content' => $html)); * </code> * * @param string $partialPath * @param array $params */ PHP_METHOD(Phalcon_Mvc_View_Simple, partial){ zval *partial_path, *params = NULL, *view_params = NULL, *merged_params = NULL; zval *content; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &partial_path, ¶ms); if (!params) { params = PHALCON_GLOBAL(z_null); } /** * Start ouput buffering */ phalcon_ob_start(TSRMLS_C); /** * If the developer pass an array of variables we create a new virtual symbol table */ if (Z_TYPE_P(params) == IS_ARRAY) { PHALCON_OBS_VAR(view_params); phalcon_read_property_this(&view_params, this_ptr, SL("_viewParams"), PH_NOISY TSRMLS_CC); /** * Merge or assign the new params as parameters */ if (Z_TYPE_P(view_params) == IS_ARRAY) { PHALCON_INIT_VAR(merged_params); phalcon_fast_array_merge(merged_params, &view_params, ¶ms TSRMLS_CC); } else { PHALCON_CPY_WRT(merged_params, params); } /** * Create a virtual symbol table */ phalcon_create_symbol_table(TSRMLS_C); } else { PHALCON_CPY_WRT(merged_params, params); } /** * Call engine render, this checks in every registered engine for the partial */ PHALCON_CALL_METHOD(NULL, this_ptr, "_internalrender", partial_path, merged_params); /** * Now we need to restore the original view parameters */ if (view_params != NULL) { /** * Restore the original view params */ phalcon_update_property_this(this_ptr, SL("_viewParams"), view_params TSRMLS_CC); } phalcon_ob_end_clean(TSRMLS_C); content = phalcon_fetch_nproperty_this(this_ptr, SL("_content"), PH_NOISY TSRMLS_CC); /** * Content is output to the parent view */ zend_print_zval(content, 0); PHALCON_MM_RESTORE(); }
/** * Phalcon\Db\Column constructor * * @param string $columnName * @param array $definition */ PHP_METHOD(Phalcon_Db_Column, __construct){ zval *column_name, *definition, *type, *not_null; zval *primary, *size, *is_numeric = NULL, *scale, *dunsigned; zval *auto_increment, *first, *after, *bind_type; zval *t0 = NULL, *t1 = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &column_name, &definition); phalcon_update_property_this(this_ptr, SL("_columnName"), column_name TSRMLS_CC); /** * Get the column type, one of the TYPE_* constants */ if (phalcon_array_isset_string(definition, SS("type"))) { PHALCON_OBS_VAR(type); phalcon_array_fetch_string(&type, definition, SL("type"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_type"), type TSRMLS_CC); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column type is required"); return; } /** * Check if the field is nullable */ if (phalcon_array_isset_string(definition, SS("notNull"))) { PHALCON_OBS_VAR(not_null); phalcon_array_fetch_string(¬_null, definition, SL("notNull"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_notNull"), not_null TSRMLS_CC); } /** * Check if the field is primary key */ if (phalcon_array_isset_string(definition, SS("primary"))) { PHALCON_OBS_VAR(primary); phalcon_array_fetch_string(&primary, definition, SL("primary"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_primary"), primary TSRMLS_CC); } if (phalcon_array_isset_string(definition, SS("size"))) { PHALCON_OBS_VAR(size); phalcon_array_fetch_string(&size, definition, SL("size"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_size"), size TSRMLS_CC); } /** * Check if the column has a decimal scale */ if (phalcon_array_isset_string(definition, SS("scale"))) { PHALCON_INIT_VAR(t0); ZVAL_LONG(t0, 3); PHALCON_INIT_VAR(is_numeric); is_equal_function(is_numeric, type, t0 TSRMLS_CC); if (PHALCON_IS_NOT_TRUE(is_numeric)) { PHALCON_INIT_VAR(t1); ZVAL_LONG(t1, 7); is_equal_function(is_numeric, type, t1 TSRMLS_CC); } if (PHALCON_IS_TRUE(is_numeric)) { PHALCON_OBS_VAR(scale); phalcon_array_fetch_string(&scale, definition, SL("scale"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_scale"), scale TSRMLS_CC); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column type does not support scale parameter"); return; } } /** * Check if the field is unsigned (only MySQL) */ if (phalcon_array_isset_string(definition, SS("unsigned"))) { PHALCON_OBS_VAR(dunsigned); phalcon_array_fetch_string(&dunsigned, definition, SL("unsigned"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_unsigned"), dunsigned TSRMLS_CC); } /** * Check if the field is numeric */ if (phalcon_array_isset_string(definition, SS("isNumeric"))) { PHALCON_OBS_NVAR(is_numeric); phalcon_array_fetch_string(&is_numeric, definition, SL("isNumeric"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_isNumeric"), is_numeric TSRMLS_CC); } /** * Check if the field is auto-increment/serial */ if (phalcon_array_isset_string(definition, SS("autoIncrement"))) { if (PHALCON_IS_LONG(type, 0)) { PHALCON_OBS_VAR(auto_increment); phalcon_array_fetch_string(&auto_increment, definition, SL("autoIncrement"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_autoIncrement"), auto_increment TSRMLS_CC); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column type cannot be auto-increment"); return; } } /** * Check if the field is placed at the first position of the table */ if (phalcon_array_isset_string(definition, SS("first"))) { PHALCON_OBS_VAR(first); phalcon_array_fetch_string(&first, definition, SL("first"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_first"), first TSRMLS_CC); } /** * Name of the column which is placed before the current field */ if (phalcon_array_isset_string(definition, SS("after"))) { PHALCON_OBS_VAR(after); phalcon_array_fetch_string(&after, definition, SL("after"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_after"), after TSRMLS_CC); } /** * The bind type to cast the field when passing it to PDO */ if (phalcon_array_isset_string(definition, SS("bindType"))) { PHALCON_OBS_VAR(bind_type); phalcon_array_fetch_string(&bind_type, definition, SL("bindType"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_bindType"), bind_type TSRMLS_CC); } PHALCON_MM_RESTORE(); }
/** * Tries to render the view with every engine registered in the component * * @param string $path * @param array $params */ PHP_METHOD(Phalcon_Mvc_View_Simple, _internalRender){ zval *path, *params, *events_manager, *event_name = NULL; zval *status = NULL, *not_exists = NULL, *views_dir; zval *views_dir_path, *engines = NULL, *engine = NULL, *extension = NULL; zval *view_engine_path = NULL, *exception_message; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &path, ¶ms); PHALCON_OBS_VAR(events_manager); phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY TSRMLS_CC); if (Z_TYPE_P(events_manager) == IS_OBJECT) { phalcon_update_property_this(this_ptr, SL("_activeRenderPath"), path TSRMLS_CC); } /** * Call beforeRender if there is an events manager */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_VAR(event_name); ZVAL_STRING(event_name, "view:beforeRender", 1); PHALCON_CALL_METHOD(&status, events_manager, "fire", event_name, this_ptr); if (PHALCON_IS_FALSE(status)) { RETURN_MM_NULL(); } } PHALCON_INIT_VAR(not_exists); ZVAL_TRUE(not_exists); PHALCON_OBS_VAR(views_dir); phalcon_read_property_this(&views_dir, this_ptr, SL("_viewsDir"), PH_NOISY TSRMLS_CC); PHALCON_INIT_VAR(views_dir_path); PHALCON_CONCAT_VV(views_dir_path, views_dir, path); /** * Load the template engines */ PHALCON_CALL_METHOD(&engines, this_ptr, "_loadtemplateengines"); /** * Views are rendered in each engine */ phalcon_is_iterable(engines, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HKEY(extension, ah0, hp0); PHALCON_GET_HVALUE(engine); PHALCON_INIT_NVAR(view_engine_path); PHALCON_CONCAT_VV(view_engine_path, views_dir_path, extension); if (phalcon_file_exists(view_engine_path TSRMLS_CC) == SUCCESS) { /** * Call beforeRenderView if there is a events manager available */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "view:beforeRenderView", 1); PHALCON_CALL_METHOD(&status, events_manager, "fire", event_name, this_ptr, view_engine_path); if (PHALCON_IS_FALSE(status)) { zend_hash_move_forward_ex(ah0, &hp0); continue; } } PHALCON_CALL_METHOD(NULL, engine, "render", view_engine_path, params, PHALCON_GLOBAL(z_true)); /** * Call afterRenderView if there is a events manager available */ PHALCON_INIT_NVAR(not_exists); ZVAL_FALSE(not_exists); if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "view:afterRenderView", 1); PHALCON_CALL_METHOD(NULL, events_manager, "fire", event_name, this_ptr); } break; } zend_hash_move_forward_ex(ah0, &hp0); } /** * Always throw an exception if the view does not exist */ if (PHALCON_IS_TRUE(not_exists)) { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "View '", views_dir_path, "' was not found in the views directory"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_view_exception_ce, exception_message); return; } /** * Call afterRender event */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "view:afterRender", 1); PHALCON_CALL_METHOD(NULL, events_manager, "fire", event_name, this_ptr); } PHALCON_MM_RESTORE(); }
/** * Renders a view * * @param string $path * @param array $params * @return string */ PHP_METHOD(Phalcon_Mvc_View_Simple, render){ zval *path, *params = NULL, *cache = NULL, *is_started = NULL, *key = NULL, *lifetime = NULL; zval *cache_options, *content = NULL, *view_params; zval *merged_params = NULL, *is_fresh = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &path, ¶ms); if (!params) { params = PHALCON_GLOBAL(z_null); } /** * Create/Get a cache */ PHALCON_CALL_METHOD(&cache, this_ptr, "getcache"); if (Z_TYPE_P(cache) == IS_OBJECT) { /** * Check if the cache is started, the first time a cache is started we start the * cache */ PHALCON_CALL_METHOD(&is_started, cache, "isstarted"); if (PHALCON_IS_FALSE(is_started)) { PHALCON_INIT_VAR(key); PHALCON_INIT_VAR(lifetime); PHALCON_OBS_VAR(cache_options); phalcon_read_property_this(&cache_options, this_ptr, SL("_cacheOptions"), PH_NOISY TSRMLS_CC); /** * Check if the user has defined a different options to the default */ if (Z_TYPE_P(cache_options) == IS_ARRAY) { if (phalcon_array_isset_string(cache_options, SS("key"))) { PHALCON_OBS_NVAR(key); phalcon_array_fetch_string(&key, cache_options, SL("key"), PH_NOISY); } if (phalcon_array_isset_string(cache_options, SS("lifetime"))) { PHALCON_OBS_NVAR(lifetime); phalcon_array_fetch_string(&lifetime, cache_options, SL("lifetime"), PH_NOISY); } } /** * If a cache key is not set we create one using a md5 */ if (Z_TYPE_P(key) == IS_NULL) { PHALCON_INIT_NVAR(key); phalcon_md5(key, path); } /** * We start the cache using the key set */ PHALCON_CALL_METHOD(&content, cache, "start", key, lifetime); if (Z_TYPE_P(content) != IS_NULL) { phalcon_update_property_this(this_ptr, SL("_content"), content TSRMLS_CC); RETURN_CTOR(content); } } } /** * Create a virtual symbol table */ phalcon_create_symbol_table(TSRMLS_C); phalcon_ob_start(TSRMLS_C); PHALCON_OBS_VAR(view_params); phalcon_read_property_this(&view_params, this_ptr, SL("_viewParams"), PH_NOISY TSRMLS_CC); /** * Merge parameters */ if (Z_TYPE_P(params) == IS_ARRAY) { if (Z_TYPE_P(view_params) == IS_ARRAY) { PHALCON_INIT_VAR(merged_params); phalcon_fast_array_merge(merged_params, &view_params, ¶ms TSRMLS_CC); } else { PHALCON_CPY_WRT(merged_params, params); } } else { PHALCON_CPY_WRT(merged_params, view_params); } /** * internalRender is also reused by partials */ PHALCON_CALL_METHOD(NULL, this_ptr, "_internalrender", path, merged_params); /** * Store the data in output into the cache */ if (Z_TYPE_P(cache) == IS_OBJECT) { PHALCON_CALL_METHOD(&is_started, cache, "isstarted"); if (PHALCON_IS_TRUE(is_started)) { PHALCON_CALL_METHOD(&is_fresh, cache, "isfresh"); if (PHALCON_IS_TRUE(is_fresh)) { PHALCON_CALL_METHOD(NULL, cache, "save"); } else { PHALCON_CALL_METHOD(NULL, cache, "stop"); } } else { PHALCON_CALL_METHOD(NULL, cache, "stop"); } } phalcon_ob_end_clean(TSRMLS_C); PHALCON_OBS_NVAR(content); phalcon_read_property_this(&content, this_ptr, SL("_content"), PH_NOISY TSRMLS_CC); RETURN_CTOR(content); }
/** * Generates a URL * *<code> * * //Generate a URL appending the URI to the base URI * echo $url->get('products/edit/1'); * * //Generate a URL for a predefined route * echo $url->get(array('for' => 'blog-post', 'title' => 'some-cool-stuff', 'year' => '2012')); * *</code> * * @param string|array $uri * @param array|object args Optional arguments to be appended to the query string * @param bool|null $local * @return string */ PHP_METHOD(Phalcon_Mvc_Url, get){ zval **uri = NULL, *base_uri = NULL, *router = NULL, *dependency_injector; zval *service, *route_name, *route = NULL, *exception_message; zval *pattern = NULL, *paths = NULL, *processed_uri, **args = NULL, *query_string; zval *matched, *regexp; zval **z_local = NULL; int local = 1; phalcon_fetch_params_ex(0, 3, &uri, &args, &z_local); PHALCON_MM_GROW(); if (!uri) { uri = &PHALCON_GLOBAL(z_null); } else if (z_local && Z_TYPE_PP(z_local) != IS_NULL) { if (!zend_is_true(*z_local)) { local = 0; } } else if (Z_TYPE_PP(uri) == IS_STRING && strstr(Z_STRVAL_PP(uri), ":")) { PHALCON_INIT_VAR(matched); PHALCON_INIT_VAR(regexp); ZVAL_STRING(regexp, "/^[^:\\/?#]++:/", 1); RETURN_MM_ON_FAILURE(phalcon_preg_match(matched, regexp, *uri, NULL TSRMLS_CC)); if (zend_is_true(matched)) { local = 0; } } PHALCON_CALL_METHOD(&base_uri, this_ptr, "getbaseuri"); if (Z_TYPE_PP(uri) == IS_ARRAY) { if (!phalcon_array_isset_string_fetch(&route_name, *uri, SS("for"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_url_exception_ce, "It's necessary to define the route name with the parameter \"for\""); return; } router = phalcon_fetch_nproperty_this(this_ptr, SL("_router"), PH_NOISY TSRMLS_CC); /** * Check if the router has not previously set */ if (Z_TYPE_P(router) != IS_OBJECT) { dependency_injector = phalcon_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY TSRMLS_CC); if (!zend_is_true(dependency_injector)) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_url_exception_ce, "A dependency injector container is required to obtain the \"url\" service"); return; } PHALCON_INIT_VAR(service); PHALCON_ZVAL_MAYBE_INTERNED_STRING(service, phalcon_interned_router); router = NULL; PHALCON_CALL_METHOD(&router, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(router, phalcon_mvc_routerinterface_ce); phalcon_update_property_this(this_ptr, SL("_router"), router TSRMLS_CC); } /** * Every route is uniquely identified by a name */ PHALCON_CALL_METHOD(&route, router, "getroutebyname", route_name); if (Z_TYPE_P(route) != IS_OBJECT) { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Cannot obtain a route using the name \"", route_name, "\""); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_url_exception_ce, exception_message); return; } PHALCON_CALL_METHOD(&pattern, route, "getpattern"); /** * Return the reversed paths */ PHALCON_CALL_METHOD(&paths, route, "getreversedpaths"); /** * Replace the patterns by its variables */ PHALCON_INIT_VAR(processed_uri); phalcon_replace_paths(processed_uri, pattern, paths, *uri TSRMLS_CC); PHALCON_CONCAT_VV(return_value, base_uri, processed_uri); } else { if (local) { PHALCON_CONCAT_VV(return_value, base_uri, *uri); } else { ZVAL_ZVAL(return_value, *uri, 1, 0); } } if (args) { PHALCON_INIT_VAR(query_string); phalcon_http_build_query(query_string, *args, "&" TSRMLS_CC); if (Z_TYPE_P(query_string) == IS_STRING && Z_STRLEN_P(query_string)) { if (phalcon_memnstr_str(return_value, "?", 1)) { PHALCON_SCONCAT_SV(return_value, "&", query_string); } else { PHALCON_SCONCAT_SV(return_value, "?", query_string); } } } RETURN_MM(); }
/** * Loads registered template engines, if none is registered it will use Phalcon\Mvc\View\Engine\Php * * @return array */ PHP_METHOD(Phalcon_Mvc_View_Simple, _loadTemplateEngines){ zval *engines = NULL, *dependency_injector, *registered_engines; zval *php_engine, *arguments, *engine_service = NULL; zval *extension = NULL, *engine_object = NULL, *exception_message = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); PHALCON_OBS_VAR(engines); phalcon_read_property_this(&engines, this_ptr, SL("_engines"), PH_NOISY TSRMLS_CC); /** * If the engines aren't initialized 'engines' is false */ if (PHALCON_IS_FALSE(engines)) { PHALCON_OBS_VAR(dependency_injector); phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY TSRMLS_CC); PHALCON_INIT_NVAR(engines); array_init(engines); PHALCON_OBS_VAR(registered_engines); phalcon_read_property_this(®istered_engines, this_ptr, SL("_registeredEngines"), PH_NOISY TSRMLS_CC); if (Z_TYPE_P(registered_engines) != IS_ARRAY) { /** * We use Phalcon\Mvc\View\Engine\Php as default */ PHALCON_INIT_VAR(php_engine); object_init_ex(php_engine, phalcon_mvc_view_engine_php_ce); PHALCON_CALL_METHOD(NULL, php_engine, "__construct", this_ptr, dependency_injector); /** * Use .phtml as extension for the PHP engine */ phalcon_array_update_string(&engines, SL(".phtml"), php_engine, PH_COPY | PH_SEPARATE); } else { if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_view_exception_ce, "A dependency injector container is required to obtain the application services"); return; } /** * Arguments for instantiated engines */ PHALCON_INIT_VAR(arguments); array_init_size(arguments, 2); phalcon_array_append(&arguments, this_ptr, PH_SEPARATE); phalcon_array_append(&arguments, dependency_injector, PH_SEPARATE); phalcon_is_iterable(registered_engines, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HKEY(extension, ah0, hp0); PHALCON_GET_HVALUE(engine_service); if (Z_TYPE_P(engine_service) == IS_OBJECT) { /** * Engine can be a closure */ if (instanceof_function(Z_OBJCE_P(engine_service), zend_ce_closure TSRMLS_CC)) { PHALCON_INIT_NVAR(engine_object);/**/ PHALCON_CALL_USER_FUNC_ARRAY(engine_object, engine_service, arguments); } else { PHALCON_CPY_WRT(engine_object, engine_service); } } else { /** * Engine can be a string representing a service in the DI */ if (Z_TYPE_P(engine_service) == IS_STRING) { PHALCON_CALL_METHOD(&engine_object, dependency_injector, "getshared", engine_service, arguments); PHALCON_VERIFY_INTERFACE(engine_object, phalcon_mvc_view_engineinterface_ce); } else { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SV(exception_message, "Invalid template engine registration for extension: ", extension); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_view_exception_ce, exception_message); return; } } phalcon_array_update_zval(&engines, extension, engine_object, PH_COPY | PH_SEPARATE); zend_hash_move_forward_ex(ah0, &hp0); } } phalcon_update_property_this(this_ptr, SL("_engines"), engines TSRMLS_CC); } else { PHALCON_OBS_NVAR(engines); phalcon_read_property_this(&engines, this_ptr, SL("_engines"), PH_NOISY TSRMLS_CC); } RETURN_CCTOR(engines); }
/** * Attach a listener to the events manager * * @param string $eventType * @param object $handler * @param int $priority */ PHP_METHOD(Phalcon_Events_Manager, attach){ zval *event_type, *handler, *priority = NULL, *events = NULL; zval *enable_priorities, *priority_queue = NULL; zval *mode; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 1, &event_type, &handler, &priority); if (!priority) { PHALCON_INIT_VAR(priority); ZVAL_LONG(priority, 100); } if (unlikely(Z_TYPE_P(event_type) != IS_STRING)) { PHALCON_THROW_EXCEPTION_STR(phalcon_events_exception_ce, "Event type must be a string"); return; } if (unlikely(Z_TYPE_P(handler) != IS_OBJECT)) { PHALCON_THROW_EXCEPTION_STR(phalcon_events_exception_ce, "Event handler must be an Object"); return; } PHALCON_OBS_VAR(events); phalcon_read_property_this(&events, this_ptr, SL("_events"), PH_NOISY_CC); if (Z_TYPE_P(events) != IS_ARRAY) { PHALCON_INIT_NVAR(events); array_init(events); } if (!phalcon_array_isset(events, event_type)) { PHALCON_OBS_VAR(enable_priorities); phalcon_read_property_this(&enable_priorities, this_ptr, SL("_enablePriorities"), PH_NOISY_CC); if (zend_is_true(enable_priorities)) { /** * Create a SplPriorityQueue to store the events with priorities */ PHALCON_INIT_VAR(priority_queue); object_init_ex(priority_queue, spl_ce_SplPriorityQueue); if (phalcon_has_constructor(priority_queue TSRMLS_CC)) { phalcon_call_method_noret(priority_queue, "__construct"); } /** * Extract only the Data */ PHALCON_INIT_VAR(mode); ZVAL_LONG(mode, 1); /** * Set extraction flags */ phalcon_call_method_p1_noret(priority_queue, "setextractflags", mode); /** * Append the events to the queue */ phalcon_array_update_zval(&events, event_type, &priority_queue, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_events"), events TSRMLS_CC); } else { PHALCON_INIT_NVAR(priority_queue); array_init(priority_queue); } } else { /** * Get the current SplPriorityQueue */ PHALCON_OBS_NVAR(priority_queue); phalcon_array_fetch(&priority_queue, events, event_type, PH_NOISY_CC); } /** * Insert the handler in the queue */ if (unlikely(Z_TYPE_P(priority_queue) == IS_OBJECT)) { phalcon_call_method_p2_noret(priority_queue, "insert", handler, priority); } else { phalcon_array_append(&priority_queue, handler, PH_SEPARATE TSRMLS_CC); /** * Append the events to the queue */ phalcon_array_update_zval(&events, event_type, &priority_queue, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_events"), events TSRMLS_CC); } PHALCON_MM_RESTORE(); }
/** * 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(); PHALCON_OBS_VAR(restored); phalcon_read_property_this(&restored, this_ptr, SL("_restored"), PH_NOISY TSRMLS_CC); if (!zend_is_true(restored)) { PHALCON_OBS_VAR(dependency_injector); phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY TSRMLS_CC); if (Z_TYPE_P(dependency_injector) == IS_OBJECT) { PHALCON_INIT_VAR(service); PHALCON_ZVAL_MAYBE_INTERNED_STRING(service, phalcon_interned_session); PHALCON_CALL_METHOD(&session, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(session, phalcon_session_adapterinterface_ce); PHALCON_OBS_VAR(name); phalcon_read_property_this(&name, this_ptr, SL("_name"), PH_NOISY TSRMLS_CC); 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_string(definition, SS("expire"))) { PHALCON_OBS_VAR(expire); phalcon_array_fetch_string(&expire, definition, SL("expire"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_expire"), expire TSRMLS_CC); } if (phalcon_array_isset_string(definition, SS("domain"))) { PHALCON_OBS_VAR(domain); phalcon_array_fetch_string(&domain, definition, SL("domain"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_domain"), domain TSRMLS_CC); } if (phalcon_array_isset_string(definition, SS("path"))) { PHALCON_OBS_VAR(path); phalcon_array_fetch_string(&path, definition, SL("path"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_path"), path TSRMLS_CC); } if (phalcon_array_isset_string(definition, SS("secure"))) { PHALCON_OBS_VAR(secure); phalcon_array_fetch_string(&secure, definition, SL("secure"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_secure"), secure TSRMLS_CC); } if (phalcon_array_isset_string(definition, SS("httpOnly"))) { PHALCON_OBS_VAR(http_only); phalcon_array_fetch_string(&http_only, definition, SL("httpOnly"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_httpOnly"), http_only TSRMLS_CC); } } } phalcon_update_property_bool(this_ptr, SL("_restored"), 1 TSRMLS_CC); } RETURN_THIS(); }
/** * Phalcon\Db\Reference constructor * * @param string $referenceName * @param array $definition */ PHP_METHOD(Phalcon_Db_Reference, __construct){ zval *reference_name, *definition, *referenced_table; zval *columns, *referenced_columns, *schema; zval *referenced_schema, *number_columns; zval *number_referenced_columns; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &reference_name, &definition); phalcon_update_property_this(this_ptr, SL("_referenceName"), reference_name TSRMLS_CC); if (phalcon_array_isset_string(definition, SS("referencedTable"))) { PHALCON_OBS_VAR(referenced_table); phalcon_array_fetch_string(&referenced_table, definition, SL("referencedTable"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_referencedTable"), referenced_table TSRMLS_CC); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Referenced table is required"); return; } if (phalcon_array_isset_string(definition, SS("columns"))) { PHALCON_OBS_VAR(columns); phalcon_array_fetch_string(&columns, definition, SL("columns"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_columns"), columns TSRMLS_CC); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Foreign key columns are required"); return; } if (phalcon_array_isset_string(definition, SS("referencedColumns"))) { PHALCON_OBS_VAR(referenced_columns); phalcon_array_fetch_string(&referenced_columns, definition, SL("referencedColumns"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_referencedColumns"), referenced_columns TSRMLS_CC); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Referenced columns of the foreign key are required"); return; } if (phalcon_array_isset_string(definition, SS("schema"))) { PHALCON_OBS_VAR(schema); phalcon_array_fetch_string(&schema, definition, SL("schema"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_schemaName"), schema TSRMLS_CC); } if (phalcon_array_isset_string(definition, SS("referencedSchema"))) { PHALCON_OBS_VAR(referenced_schema); phalcon_array_fetch_string(&referenced_schema, definition, SL("referencedSchema"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_referencedSchema"), referenced_schema TSRMLS_CC); } PHALCON_INIT_VAR(number_columns); phalcon_fast_count(number_columns, columns TSRMLS_CC); PHALCON_INIT_VAR(number_referenced_columns); phalcon_fast_count(number_referenced_columns, referenced_columns TSRMLS_CC); if (!PHALCON_IS_EQUAL(number_columns, number_referenced_columns)) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Number of columns is not equals than the number of columns referenced"); return; } PHALCON_MM_RESTORE(); }
/** * Returns a cached content * * @param int|string $keyName * @param long $lifetime * @return mixed */ PHP_METHOD(Phalcon_Cache_Backend_Mongo, get){ zval *key_name, *lifetime = NULL, *frontend, *prefix, *prefixed_key; zval *collection, *conditions, *document, *timestamp; zval *ttl = NULL, *modified_time, *difference, *not_expired; zval *cached_content; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &key_name, &lifetime); if (!lifetime) { PHALCON_INIT_VAR(lifetime); } else { PHALCON_SEPARATE_PARAM(lifetime); } PHALCON_OBS_VAR(frontend); phalcon_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC); PHALCON_OBS_VAR(prefix); phalcon_read_property_this(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC); PHALCON_INIT_VAR(prefixed_key); PHALCON_CONCAT_VV(prefixed_key, prefix, key_name); phalcon_update_property_this(this_ptr, SL("_lastKey"), prefixed_key TSRMLS_CC); PHALCON_INIT_VAR(collection); phalcon_call_method(collection, this_ptr, "_getcollection"); PHALCON_INIT_VAR(conditions); array_init_size(conditions, 1); phalcon_array_update_string(&conditions, SL("key"), &prefixed_key, PH_COPY | PH_SEPARATE); PHALCON_INIT_VAR(document); phalcon_call_method_p1(document, collection, "findone", conditions); if (Z_TYPE_P(document) == IS_ARRAY) { PHALCON_INIT_VAR(timestamp); ZVAL_LONG(timestamp, (long) time(NULL)); /** * Take the lifetime from the frontend or read it from the set in start() */ if (Z_TYPE_P(lifetime) == IS_NULL) { PHALCON_OBS_NVAR(lifetime); phalcon_read_property_this(&lifetime, this_ptr, SL("_lastLifetime"), PH_NOISY_CC); if (Z_TYPE_P(lifetime) == IS_NULL) { PHALCON_INIT_VAR(ttl); phalcon_call_method(ttl, frontend, "getlifetime"); } else { PHALCON_CPY_WRT(ttl, lifetime); } } else { PHALCON_CPY_WRT(ttl, lifetime); } if (!phalcon_array_isset_string(document, SS("time"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache is currupted"); return; } PHALCON_OBS_VAR(modified_time); phalcon_array_fetch_string(&modified_time, document, SL("time"), PH_NOISY); PHALCON_INIT_VAR(difference); sub_function(difference, timestamp, ttl TSRMLS_CC); PHALCON_INIT_VAR(not_expired); is_smaller_function(not_expired, difference, modified_time TSRMLS_CC); /** * The expiration is based on the column 'time' */ if (PHALCON_IS_TRUE(not_expired)) { if (!phalcon_array_isset_string(document, SS("data"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache is currupted"); return; } PHALCON_OBS_VAR(cached_content); phalcon_array_fetch_string(&cached_content, document, SL("data"), PH_NOISY); phalcon_call_method_p1(return_value, frontend, "afterretrieve", cached_content); RETURN_MM(); } } RETURN_MM_NULL(); }
/** * Executes render process from dispatching data * *<code> * $view->start(); * //Shows recent posts view (app/views/posts/recent.phtml) * $view->render('posts', 'recent'); * $view->finish(); *</code> * * @param string $controllerName * @param string $actionName * @param array $params */ PHP_METHOD(Phalcon_Mvc_View, render){ zval *controller_name, *action_name, *params = NULL; zval *disabled, *contents = NULL, *layouts_dir = NULL, *layout; zval *layout_name = NULL, *engines, *pick_view, *render_view = NULL; zval *pick_view_action, *cache = NULL, *cache_level; zval *events_manager, *event_name = NULL, *status, *must_clean; zval *silence = NULL, *disabled_levels, *render_level; zval *enter_level = NULL, *templates_before, *template_before = NULL; zval *view_temp_path = NULL, *templates_after, *template_after = NULL; zval *main_view, *is_started, *is_fresh; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 1, &controller_name, &action_name, ¶ms); if (!params) { PHALCON_INIT_VAR(params); } /** * If the view is disabled we simply update the buffer from any output produced in * the controller */ PHALCON_OBS_VAR(disabled); phalcon_read_property_this(&disabled, this_ptr, SL("_disabled"), PH_NOISY_CC); if (PHALCON_IS_NOT_FALSE(disabled)) { PHALCON_INIT_VAR(contents); PHALCON_CALL_FUNC(contents, "ob_get_contents"); phalcon_update_property_this(this_ptr, SL("_content"), contents TSRMLS_CC); RETURN_MM_FALSE; } phalcon_update_property_this(this_ptr, SL("_controllerName"), controller_name TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_actionName"), action_name TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_params"), params TSRMLS_CC); /** * Check if there is a layouts directory set */ PHALCON_OBS_VAR(layouts_dir); phalcon_read_property_this(&layouts_dir, this_ptr, SL("_layoutsDir"), PH_NOISY_CC); if (!zend_is_true(layouts_dir)) { PHALCON_INIT_NVAR(layouts_dir); ZVAL_STRING(layouts_dir, "layouts/", 1); } /** * Check if the user has defined a custom layout */ PHALCON_OBS_VAR(layout); phalcon_read_property_this(&layout, this_ptr, SL("_layout"), PH_NOISY_CC); if (zend_is_true(layout)) { PHALCON_CPY_WRT(layout_name, layout); } else { PHALCON_CPY_WRT(layout_name, controller_name); } /** * Load the template engines */ PHALCON_INIT_VAR(engines); PHALCON_CALL_METHOD(engines, this_ptr, "_loadtemplateengines"); /** * Check if the user has picked a view diferent than the automatic */ PHALCON_OBS_VAR(pick_view); phalcon_read_property_this(&pick_view, this_ptr, SL("_pickView"), PH_NOISY_CC); if (Z_TYPE_P(pick_view) == IS_NULL) { PHALCON_INIT_VAR(render_view); PHALCON_CONCAT_VSV(render_view, controller_name, "/", action_name); } else { /** * The 'picked' view is an array, where the first element is controller and the * second the action */ PHALCON_OBS_NVAR(render_view); phalcon_array_fetch_long(&render_view, pick_view, 0, PH_NOISY_CC); if (phalcon_array_isset_long(pick_view, 1)) { PHALCON_OBS_VAR(pick_view_action); phalcon_array_fetch_long(&pick_view_action, pick_view, 1, PH_NOISY_CC); PHALCON_CPY_WRT(layout_name, pick_view_action); } } PHALCON_INIT_VAR(cache); /** * Start the cache if there is a cache level enabled */ PHALCON_OBS_VAR(cache_level); phalcon_read_property_this(&cache_level, this_ptr, SL("_cacheLevel"), PH_NOISY_CC); if (zend_is_true(cache_level)) { PHALCON_CALL_METHOD(cache, this_ptr, "getcache"); } PHALCON_OBS_VAR(events_manager); phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); /** * Create a virtual symbol table */ phalcon_create_symbol_table(TSRMLS_C); /** * Call beforeRender if there is an events manager */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_VAR(event_name); ZVAL_STRING(event_name, "view:beforeRender", 1); PHALCON_INIT_VAR(status); PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", event_name, this_ptr); if (PHALCON_IS_FALSE(status)) { RETURN_MM_FALSE; } } /** * Get the current content in the buffer maybe some output from the controller */ PHALCON_INIT_NVAR(contents); PHALCON_CALL_FUNC(contents, "ob_get_contents"); phalcon_update_property_this(this_ptr, SL("_content"), contents TSRMLS_CC); PHALCON_INIT_VAR(must_clean); ZVAL_BOOL(must_clean, 1); PHALCON_INIT_VAR(silence); ZVAL_BOOL(silence, 1); /** * Disabled levels allow to avoid an specific level of rendering */ PHALCON_OBS_VAR(disabled_levels); phalcon_read_property_this(&disabled_levels, this_ptr, SL("_disabledLevels"), PH_NOISY_CC); /** * Render level will tell use when to stop */ PHALCON_OBS_VAR(render_level); phalcon_read_property_this(&render_level, this_ptr, SL("_renderLevel"), PH_NOISY_CC); if (zend_is_true(render_level)) { /** * Inserts view related to action */ PHALCON_INIT_VAR(t0); ZVAL_LONG(t0, 1); PHALCON_INIT_VAR(enter_level); is_smaller_or_equal_function(enter_level, t0, render_level TSRMLS_CC); if (PHALCON_IS_TRUE(enter_level)) { if (!phalcon_array_isset_long(disabled_levels, 1)) { PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, render_view, silence, must_clean, cache); } } /** * Inserts templates before layout */ PHALCON_INIT_VAR(t1); ZVAL_LONG(t1, 2); PHALCON_INIT_NVAR(enter_level); is_smaller_or_equal_function(enter_level, t1, render_level TSRMLS_CC); if (PHALCON_IS_TRUE(enter_level)) { if (!phalcon_array_isset_long(disabled_levels, 2)) { PHALCON_OBS_VAR(templates_before); phalcon_read_property_this(&templates_before, this_ptr, SL("_templatesBefore"), PH_NOISY_CC); /** * Templates before must be an array */ if (Z_TYPE_P(templates_before) == IS_ARRAY) { ZVAL_BOOL(silence, 0); if (!phalcon_is_iterable(templates_before, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(template_before); PHALCON_INIT_NVAR(view_temp_path); PHALCON_CONCAT_VV(view_temp_path, layouts_dir, template_before); PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache); zend_hash_move_forward_ex(ah0, &hp0); } ZVAL_BOOL(silence, 1); } } } /** * Inserts controller layout */ PHALCON_INIT_VAR(t2); ZVAL_LONG(t2, 3); PHALCON_INIT_NVAR(enter_level); is_smaller_or_equal_function(enter_level, t2, render_level TSRMLS_CC); if (PHALCON_IS_TRUE(enter_level)) { if (!phalcon_array_isset_long(disabled_levels, 3)) { PHALCON_INIT_NVAR(view_temp_path); PHALCON_CONCAT_VV(view_temp_path, layouts_dir, layout_name); PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache); } } /** * Inserts templates after layout */ PHALCON_INIT_VAR(t3); ZVAL_LONG(t3, 4); PHALCON_INIT_NVAR(enter_level); is_smaller_or_equal_function(enter_level, t3, render_level TSRMLS_CC); if (PHALCON_IS_TRUE(enter_level)) { if (!phalcon_array_isset_long(disabled_levels, 4)) { /** * Templates after must be an array */ PHALCON_OBS_VAR(templates_after); phalcon_read_property_this(&templates_after, this_ptr, SL("_templatesAfter"), PH_NOISY_CC); if (Z_TYPE_P(templates_after) == IS_ARRAY) { ZVAL_BOOL(silence, 0); if (!phalcon_is_iterable(templates_after, &ah1, &hp1, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(template_after); PHALCON_INIT_NVAR(view_temp_path); PHALCON_CONCAT_VV(view_temp_path, layouts_dir, template_after); PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache); zend_hash_move_forward_ex(ah1, &hp1); } ZVAL_BOOL(silence, 1); } } } /** * Inserts main view */ PHALCON_INIT_VAR(t4); ZVAL_LONG(t4, 5); PHALCON_INIT_NVAR(enter_level); is_smaller_or_equal_function(enter_level, t4, render_level TSRMLS_CC); if (PHALCON_IS_TRUE(enter_level)) { if (!phalcon_array_isset_long(disabled_levels, 5)) { PHALCON_OBS_VAR(main_view); phalcon_read_property_this(&main_view, this_ptr, SL("_mainView"), PH_NOISY_CC); PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, main_view, silence, must_clean, cache); } } /** * Store the data in the cache */ if (Z_TYPE_P(cache) == IS_OBJECT) { PHALCON_INIT_VAR(is_started); PHALCON_CALL_METHOD(is_started, cache, "isstarted"); if (PHALCON_IS_TRUE(is_started)) { PHALCON_INIT_VAR(is_fresh); PHALCON_CALL_METHOD(is_fresh, cache, "isfresh"); if (PHALCON_IS_TRUE(is_fresh)) { PHALCON_CALL_METHOD_NORETURN(cache, "save"); } else { PHALCON_CALL_METHOD_NORETURN(cache, "stop"); } } else { PHALCON_CALL_METHOD_NORETURN(cache, "stop"); } } } /** * Call afterRender event */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "view:afterRender", 1); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", event_name, this_ptr); } RETURN_MM_NULL(); }
/** * Checks whether view exists on registered extensions and render it * * @param array $engines * @param string $viewPath * @param boolean $silence * @param boolean $mustClean * @param Phalcon\Cache\BackendInterface $cache */ PHP_METHOD(Phalcon_Mvc_View, _engineRender){ zval *engines, *view_path, *silence, *must_clean; zval *cache, *not_exists = NULL, *view_params, *views_dir; zval *base_path, *views_dir_path, *events_manager; zval *render_level, *cache_level, *enter_cache; zval *is_started, *key = NULL, *lifetime = NULL, *view_options; zval *cache_options, *cached_view, *is_fresh; zval *engine = NULL, *extension = NULL, *view_engine_path = NULL; zval *event_name = NULL, *status = NULL, *exception_message; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 5, 0, &engines, &view_path, &silence, &must_clean, &cache); PHALCON_INIT_VAR(not_exists); ZVAL_BOOL(not_exists, 1); PHALCON_OBS_VAR(view_params); phalcon_read_property_this(&view_params, this_ptr, SL("_viewParams"), PH_NOISY_CC); PHALCON_OBS_VAR(views_dir); phalcon_read_property_this(&views_dir, this_ptr, SL("_viewsDir"), PH_NOISY_CC); PHALCON_OBS_VAR(base_path); phalcon_read_property_this(&base_path, this_ptr, SL("_basePath"), PH_NOISY_CC); PHALCON_INIT_VAR(views_dir_path); PHALCON_CONCAT_VVV(views_dir_path, base_path, views_dir, view_path); PHALCON_OBS_VAR(events_manager); phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); if (Z_TYPE_P(cache) == IS_OBJECT) { PHALCON_OBS_VAR(render_level); phalcon_read_property_this(&render_level, this_ptr, SL("_renderLevel"), PH_NOISY_CC); PHALCON_OBS_VAR(cache_level); phalcon_read_property_this(&cache_level, this_ptr, SL("_cacheLevel"), PH_NOISY_CC); /** * Evaluate if we need to enter in 'cache' mode */ PHALCON_INIT_VAR(enter_cache); is_smaller_or_equal_function(enter_cache, cache_level, render_level TSRMLS_CC); if (zend_is_true(enter_cache)) { /** * Check if the cache is started, the first time a cache is started we start the * cache */ PHALCON_INIT_VAR(is_started); PHALCON_CALL_METHOD(is_started, cache, "isstarted"); if (PHALCON_IS_FALSE(is_started)) { PHALCON_INIT_VAR(key); PHALCON_INIT_VAR(lifetime); PHALCON_OBS_VAR(view_options); phalcon_read_property_this(&view_options, this_ptr, SL("_options"), PH_NOISY_CC); /** * Check if the user has defined a different options to the default */ if (Z_TYPE_P(view_options) == IS_ARRAY) { if (phalcon_array_isset_string(view_options, SS("cache"))) { PHALCON_OBS_VAR(cache_options); phalcon_array_fetch_string(&cache_options, view_options, SL("cache"), PH_NOISY_CC); if (Z_TYPE_P(cache_options) == IS_ARRAY) { if (phalcon_array_isset_string(cache_options, SS("key"))) { PHALCON_OBS_NVAR(key); phalcon_array_fetch_string(&key, cache_options, SL("key"), PH_NOISY_CC); } if (phalcon_array_isset_string(cache_options, SS("lifetime"))) { PHALCON_OBS_NVAR(lifetime); phalcon_array_fetch_string(&lifetime, cache_options, SL("lifetime"), PH_NOISY_CC); } } } } /** * If a cache key is not set we create one using a md5 */ if (Z_TYPE_P(key) == IS_NULL) { PHALCON_INIT_NVAR(key); PHALCON_CALL_FUNC_PARAMS_1(key, "md5", view_path); } /** * We start the cache using the key set */ PHALCON_INIT_VAR(cached_view); PHALCON_CALL_METHOD_PARAMS_2(cached_view, cache, "start", key, lifetime); if (Z_TYPE_P(cached_view) != IS_NULL) { phalcon_update_property_this(this_ptr, SL("_content"), cached_view TSRMLS_CC); RETURN_MM_NULL(); } } /** * This method only returns true if the cache has not expired */ PHALCON_INIT_VAR(is_fresh); PHALCON_CALL_METHOD(is_fresh, cache, "isfresh"); if (!zend_is_true(is_fresh)) { RETURN_MM_NULL(); } } } /** * Views are rendered in each engine */ if (!phalcon_is_iterable(engines, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_KEY(extension, ah0, hp0); PHALCON_GET_FOREACH_VALUE(engine); PHALCON_INIT_NVAR(view_engine_path); PHALCON_CONCAT_VV(view_engine_path, views_dir_path, extension); if (phalcon_file_exists(view_engine_path TSRMLS_CC) == SUCCESS) { /** * Call beforeRenderView if there is a events manager available */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { phalcon_update_property_this(this_ptr, SL("_activeRenderPath"), view_engine_path TSRMLS_CC); PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "view:beforeRenderView", 1); PHALCON_INIT_NVAR(status); PHALCON_CALL_METHOD_PARAMS_3(status, events_manager, "fire", event_name, this_ptr, view_engine_path); if (PHALCON_IS_FALSE(status)) { zend_hash_move_forward_ex(ah0, &hp0); continue; } } PHALCON_CALL_METHOD_PARAMS_3_NORETURN(engine, "render", view_engine_path, view_params, must_clean); /** * Call afterRenderView if there is a events manager available */ PHALCON_INIT_NVAR(not_exists); ZVAL_BOOL(not_exists, 0); if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "view:afterRenderView", 1); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", event_name, this_ptr); } break; } zend_hash_move_forward_ex(ah0, &hp0); } if (PHALCON_IS_TRUE(not_exists)) { /** * Notify about not found views */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { phalcon_update_property_this(this_ptr, SL("_activeRenderPath"), view_engine_path TSRMLS_CC); PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "view:notFoundView", 1); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", event_name, this_ptr); } if (!zend_is_true(silence)) { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "View '", views_dir_path, "' was not found in the views directory"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_view_exception_ce, exception_message); return; } } PHALCON_MM_RESTORE(); }
/** * Cache the actual view render to certain level * * @param boolean|array $options */ PHP_METHOD(Phalcon_Mvc_View, cache){ zval *options = NULL, *view_options = NULL, *cache_options = NULL; zval *value = NULL, *key = NULL, *cache_level; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, &options); if (!options) { PHALCON_INIT_VAR(options); ZVAL_BOOL(options, 1); } if (Z_TYPE_P(options) == IS_ARRAY) { PHALCON_OBS_VAR(view_options); phalcon_read_property_this(&view_options, this_ptr, SL("_options"), PH_NOISY_CC); if (Z_TYPE_P(view_options) != IS_ARRAY) { PHALCON_INIT_NVAR(view_options); array_init(view_options); } /** * Get the default cache options */ if (phalcon_array_isset_string(view_options, SS("cache"))) { PHALCON_OBS_VAR(cache_options); phalcon_array_fetch_string(&cache_options, view_options, SL("cache"), PH_NOISY_CC); } else { PHALCON_INIT_NVAR(cache_options); array_init(cache_options); } if (!phalcon_is_iterable(options, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_KEY(key, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); phalcon_array_update_zval(&cache_options, key, &value, PH_COPY | PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); } /** * Check if the user has defined a default cache level or use 5 as default */ if (phalcon_array_isset_string(cache_options, SS("level"))) { PHALCON_OBS_VAR(cache_level); phalcon_array_fetch_string(&cache_level, cache_options, SL("level"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_cacheLevel"), cache_level TSRMLS_CC); } else { phalcon_update_property_long(this_ptr, SL("_cacheLevel"), 5 TSRMLS_CC); } phalcon_array_update_string(&view_options, SL("cache"), &cache_options, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_options"), view_options TSRMLS_CC); } else { /** * If 'options' isn't an array we enable the cache with the default options */ if (zend_is_true(options)) { phalcon_update_property_long(this_ptr, SL("_cacheLevel"), 5 TSRMLS_CC); } else { phalcon_update_property_long(this_ptr, SL("_cacheLevel"), 0 TSRMLS_CC); } } PHALCON_MM_RESTORE(); }
/** * Reconfigure the route adding a new pattern and a set of paths * * @param string $pattern * @param array $paths */ PHP_METHOD(Phalcon_Mvc_Router_Route, reConfigure){ zval *pattern, *paths = NULL, *module_name = NULL, *controller_name = NULL; zval *action_name = NULL, *parts, *number_parts, *route_paths = NULL; zval *real_class_name = NULL, *namespace_name, *lower_name; zval *pcre_pattern = NULL, *compiled_pattern = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &pattern, &paths); if (!paths) { PHALCON_INIT_VAR(paths); } if (Z_TYPE_P(pattern) != IS_STRING) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_router_exception_ce, "The pattern must be string"); return; } if (Z_TYPE_P(paths) != IS_NULL) { if (Z_TYPE_P(paths) == IS_STRING) { PHALCON_INIT_VAR(module_name); PHALCON_INIT_VAR(controller_name); PHALCON_INIT_VAR(action_name); /** * Explode the short paths using the :: separator */ PHALCON_INIT_VAR(parts); phalcon_fast_explode_str(parts, SL("::"), paths); PHALCON_INIT_VAR(number_parts); phalcon_fast_count(number_parts, parts TSRMLS_CC); /** * Create the array paths dynamically */ switch (phalcon_get_intval(number_parts)) { case 3: PHALCON_OBS_NVAR(module_name); phalcon_array_fetch_long(&module_name, parts, 0, PH_NOISY); PHALCON_OBS_NVAR(controller_name); phalcon_array_fetch_long(&controller_name, parts, 1, PH_NOISY); PHALCON_OBS_NVAR(action_name); phalcon_array_fetch_long(&action_name, parts, 2, PH_NOISY); break; case 2: PHALCON_OBS_NVAR(controller_name); phalcon_array_fetch_long(&controller_name, parts, 0, PH_NOISY); PHALCON_OBS_NVAR(action_name); phalcon_array_fetch_long(&action_name, parts, 1, PH_NOISY); break; case 1: PHALCON_OBS_NVAR(controller_name); phalcon_array_fetch_long(&controller_name, parts, 0, PH_NOISY); break; } PHALCON_INIT_VAR(route_paths); array_init(route_paths); /** * Process module name */ if (Z_TYPE_P(module_name) != IS_NULL) { phalcon_array_update_string(&route_paths, SL("module"), &module_name, PH_COPY | PH_SEPARATE); } /** * Process controller name */ if (Z_TYPE_P(controller_name) != IS_NULL) { /** * Check if we need to obtain the namespace */ if (phalcon_memnstr_str(controller_name, SL("\\"))) { /** * Extract the real class name from the namespaced class */ PHALCON_INIT_VAR(real_class_name); phalcon_get_class_ns(real_class_name, controller_name, 0 TSRMLS_CC); /** * Extract the namespace from the namespaced class */ PHALCON_INIT_VAR(namespace_name); phalcon_get_ns_class(namespace_name, controller_name, 0 TSRMLS_CC); /** * Update the namespace */ if (zend_is_true(namespace_name)) { phalcon_array_update_string(&route_paths, SL("namespace"), &namespace_name, PH_COPY | PH_SEPARATE); } } else { PHALCON_CPY_WRT(real_class_name, controller_name); } /** * Always pass the controller to lowercase */ PHALCON_INIT_VAR(lower_name); phalcon_uncamelize(lower_name, real_class_name); /** * Update the controller path */ phalcon_array_update_string(&route_paths, SL("controller"), &lower_name, PH_COPY | PH_SEPARATE); } /** * Process action name */ if (Z_TYPE_P(action_name) != IS_NULL) { phalcon_array_update_string(&route_paths, SL("action"), &action_name, PH_COPY | PH_SEPARATE); } } else { PHALCON_CPY_WRT(route_paths, paths); } } else { PHALCON_INIT_NVAR(route_paths); array_init(route_paths); } if (Z_TYPE_P(route_paths) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_router_exception_ce, "The route contains invalid paths"); return; } /** * If the route starts with '#' we assume that it is a regular expression */ if (!phalcon_start_with_str(pattern, SL("#"))) { if (phalcon_memnstr_str(pattern, SL("{"))) { /** * The route has named parameters so we need to extract them */ PHALCON_INIT_VAR(pcre_pattern); phalcon_extract_named_params(pcre_pattern, pattern, route_paths); } else { PHALCON_CPY_WRT(pcre_pattern, pattern); } /** * Transform the route's pattern to a regular expression */ PHALCON_INIT_VAR(compiled_pattern); phalcon_call_method_p1(compiled_pattern, this_ptr, "compilepattern", pcre_pattern); } else { PHALCON_CPY_WRT(compiled_pattern, pattern); } /** * Update the original pattern */ phalcon_update_property_this(this_ptr, SL("_pattern"), pattern TSRMLS_CC); /** * Update the compiled pattern */ phalcon_update_property_this(this_ptr, SL("_compiledPattern"), compiled_pattern TSRMLS_CC); /** * Update the route's paths */ phalcon_update_property_this(this_ptr, SL("_paths"), route_paths TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Returns a cached content * * @param int|string $keyName * @param long $lifetime * @return mixed */ PHP_METHOD(Phalcon_Cache_Backend_File, get){ zval *key_name, *lifetime = NULL; zval *options, *prefix, *prefixed_key, *cache_dir; zval *cache_file, *tmp = NULL; zval *modified_time; zval *cached_content, *exception_message; long int now, ttl, mtime, diff; int expired; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &key_name, &lifetime); options = phalcon_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY TSRMLS_CC); prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC); PHALCON_INIT_VAR(prefixed_key); PHALCON_CONCAT_VV(prefixed_key, prefix, key_name); phalcon_update_property_this(this_ptr, SL("_lastKey"), prefixed_key TSRMLS_CC); if (unlikely(!phalcon_array_isset_string_fetch(&cache_dir, options, SS("cacheDir")))) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options"); return; } PHALCON_INIT_VAR(cache_file); PHALCON_CONCAT_VV(cache_file, cache_dir, prefixed_key); if (phalcon_file_exists(cache_file TSRMLS_CC) == SUCCESS) { zval *frontend = phalcon_fetch_nproperty_this(this_ptr, SL("_frontend"), PH_NOISY TSRMLS_CC); /** * Check if the file has expired */ now = (long int)time(NULL); /** * Take the lifetime from the frontend or read it from the set in start() */ if (!lifetime || Z_TYPE_P(lifetime) == IS_NULL) { zval *last_lifetime = phalcon_fetch_nproperty_this(this_ptr, SL("_lastLifetime"), PH_NOISY TSRMLS_CC); if (Z_TYPE_P(last_lifetime) == IS_NULL) { PHALCON_CALL_METHOD(&tmp, frontend, "getlifetime"); ttl = phalcon_get_intval(tmp); } else { ttl = phalcon_get_intval(last_lifetime); } } else { ttl = phalcon_get_intval(lifetime); } PHALCON_INIT_VAR(modified_time); phalcon_filemtime(modified_time, cache_file TSRMLS_CC); if (unlikely(Z_TYPE_P(modified_time) != IS_LONG)) { convert_to_long(modified_time); } mtime = Z_LVAL_P(modified_time); diff = now - ttl; expired = diff > mtime; /** * The content is only retrieved if the content has not expired */ if (!expired) { /** * Use file-get-contents to control that the openbase_dir can't be skipped */ PHALCON_INIT_VAR(cached_content); phalcon_file_get_contents(cached_content, cache_file TSRMLS_CC); if (PHALCON_IS_FALSE(cached_content)) { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Cache file ", cache_file, " could not be opened"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_cache_exception_ce, exception_message); return; } if (phalcon_is_numeric(cached_content)) { RETURN_CCTOR(cached_content); } else { /** * Use the frontend to process the content of the cache */ PHALCON_RETURN_CALL_METHOD(frontend, "afterretrieve", cached_content); } RETURN_MM(); } } RETURN_MM_NULL(); }
/** * Returns the cookie's value * * @param string|array $filters * @param string $defaultValue * @return mixed */ PHP_METHOD(Phalcon_Http_Cookie, getValue){ zval *filters = NULL, *default_value = NULL, *restored, *dependency_injector = NULL; zval *readed, *name, *_COOKIE, *value = NULL, *encryption; zval *service = NULL, *crypt = NULL, *decrypted_value = NULL, *filter = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 2, &filters, &default_value); if (!filters) { filters = PHALCON_GLOBAL(z_null); } if (!default_value) { default_value = PHALCON_GLOBAL(z_null); } PHALCON_OBS_VAR(restored); phalcon_read_property_this(&restored, this_ptr, SL("_restored"), PH_NOISY TSRMLS_CC); if (!zend_is_true(restored)) { PHALCON_CALL_METHOD(NULL, this_ptr, "restore"); } PHALCON_INIT_VAR(dependency_injector); PHALCON_OBS_VAR(readed); phalcon_read_property_this(&readed, this_ptr, SL("_readed"), PH_NOISY TSRMLS_CC); if (PHALCON_IS_FALSE(readed)) { PHALCON_OBS_VAR(name); phalcon_read_property_this(&name, this_ptr, SL("_name"), PH_NOISY TSRMLS_CC); _COOKIE = phalcon_get_global(SS("_COOKIE") TSRMLS_CC); if (phalcon_array_isset_fetch(&value, _COOKIE, name)) { PHALCON_OBS_VAR(encryption); phalcon_read_property_this(&encryption, this_ptr, SL("_useEncryption"), PH_NOISY TSRMLS_CC); if (zend_is_true(encryption)) { PHALCON_OBS_NVAR(dependency_injector); phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY TSRMLS_CC); if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_http_cookie_exception_ce, "A dependency injection object is required to access the 'filter' service"); return; } PHALCON_INIT_VAR(service); ZVAL_STRING(service, "crypt", 1); PHALCON_CALL_METHOD(&crypt, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(crypt, phalcon_cryptinterface_ce); /** * Decrypt the value also decoding it with base64 */ PHALCON_CALL_METHOD(&decrypted_value, crypt, "decryptbase64", value); } else { PHALCON_CPY_WRT(decrypted_value, value); } /** * Update the decrypted value */ phalcon_update_property_this(this_ptr, SL("_value"), decrypted_value TSRMLS_CC); if (Z_TYPE_P(filters) != IS_NULL) { PHALCON_OBS_VAR(filter); phalcon_read_property_this(&filter, this_ptr, SL("_filter"), PH_NOISY TSRMLS_CC); if (Z_TYPE_P(filter) != IS_OBJECT) { if (Z_TYPE_P(dependency_injector) == IS_NULL) { PHALCON_OBS_NVAR(dependency_injector); phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY TSRMLS_CC); PHALCON_VERIFY_INTERFACE_EX(dependency_injector, phalcon_diinterface_ce, phalcon_http_cookie_exception_ce, 1); } PHALCON_INIT_NVAR(service); PHALCON_ZVAL_MAYBE_INTERNED_STRING(service, phalcon_interned_filter); PHALCON_CALL_METHOD(&filter, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(filter, phalcon_filterinterface_ce); phalcon_update_property_this(this_ptr, SL("_filter"), filter TSRMLS_CC); } PHALCON_RETURN_CALL_METHOD(filter, "sanitize", decrypted_value, filters); RETURN_MM(); } /** * Return the value without filtering */ RETURN_CTOR(decrypted_value); } RETURN_CTOR(default_value); } PHALCON_OBS_NVAR(value); phalcon_read_property_this(&value, this_ptr, SL("_value"), PH_NOISY TSRMLS_CC); RETURN_CTOR(value); }
/** * Handle the command-line arguments. * * * <code> * $arguments = array( * 'task' => 'taskname', * 'action' => 'action', * 'params' => array('parameter1', 'parameter2') * ); * $console->handle($arguments); * </code> * * @param array $arguments * @return mixed */ PHP_METHOD(Phalcon_CLI_Console, handle){ zval *_arguments = NULL, arguments = {}, dependency_injector = {}, events_manager = {}, event_name = {}, service = {}, router = {}, module_name = {}; zval status = {}, *modules, exception_msg = {}, module = {}, path = {}, class_name = {}, module_object = {}; zval namespace_name = {}, task_name = {}, action_name = {}, params = {}, dispatcher = {}; phalcon_fetch_params(0, 0, 1, &_arguments); if (!_arguments) { array_init(&arguments); } else { PHALCON_CPY_WRT(&arguments, _arguments); } phalcon_return_property(&events_manager, getThis(), SL("_eventsManager")); ZVAL_STRING(&service, ISV(router)); PHALCON_CALL_METHODW(&dependency_injector, getThis(), "getdi"); if (Z_TYPE(dependency_injector) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_FORMATW(phalcon_cli_console_exception_ce, "A dependency injection container is required to access the '%s' service", Z_STRVAL(service)); return; } PHALCON_CALL_METHODW(&router, &dependency_injector, "getshared", &service); PHALCON_VERIFY_CLASSW(&router, phalcon_cli_router_ce); PHALCON_CALL_METHODW(NULL, &router, "handle", &arguments); PHALCON_CALL_METHODW(&module_name, &router, "getmodulename"); if (zend_is_true(&module_name)) { if (Z_TYPE(events_manager) == IS_OBJECT) { ZVAL_STRING(&event_name, "console:beforeStartModule"); PHALCON_CALL_METHODW(&status, &events_manager, "fire", &event_name, getThis(), &module_name); if (PHALCON_IS_FALSE(&status)) { RETURN_FALSE; } } modules = phalcon_read_property(getThis(), SL("_modules"), PH_NOISY); if (!phalcon_array_isset_fetch(&module, modules, &module_name)) { PHALCON_CONCAT_SVS(&exception_msg, "Module '", &module_name, "' isn't registered in the console container"); PHALCON_THROW_EXCEPTION_ZVALW(phalcon_cli_console_exception_ce, &exception_msg); return; } if (Z_TYPE_P(&module) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STRW(phalcon_cli_console_exception_ce, "Invalid module definition path"); return; } if (phalcon_array_isset_fetch_str(&path, &module, SL("path"))) { convert_to_string_ex(&path); if (phalcon_file_exists(&path) == SUCCESS) { RETURN_ON_FAILURE(phalcon_require(Z_STRVAL(path))); } else { zend_throw_exception_ex(phalcon_cli_console_exception_ce, 0, "Modules definition path '%s' does not exist", Z_STRVAL(path)); return; } } if (!phalcon_array_isset_fetch_str(&class_name, &module, SL("className"))) { ZVAL_STRING(&class_name, "Module"); } PHALCON_CALL_METHODW(&module_object, &dependency_injector, "getshared", &class_name); PHALCON_CALL_METHODW(NULL, &module_object, "registerautoloaders"); PHALCON_CALL_METHODW(NULL, &module_object, "registerservices", &dependency_injector); if (Z_TYPE(events_manager) == IS_OBJECT) { phalcon_update_property_this(getThis(), SL("_moduleObject"), &module_object); ZVAL_STRING(&event_name, "console:afterStartModule"); PHALCON_CALL_METHODW(&status, &events_manager, "fire", &event_name, getThis(), &module_name); if (PHALCON_IS_FALSE(&status)) { RETURN_FALSE; } } } PHALCON_CALL_METHODW(&namespace_name, &router, "getnamespacename"); PHALCON_CALL_METHODW(&task_name, &router, "gettaskname"); PHALCON_CALL_METHODW(&action_name, &router, "getactionname"); PHALCON_CALL_METHODW(¶ms, &router, "getparams"); ZVAL_STRING(&service, ISV(dispatcher)); PHALCON_CALL_METHODW(&dispatcher, &dependency_injector, "getshared", &service); PHALCON_VERIFY_INTERFACEW(&dispatcher, phalcon_dispatcherinterface_ce); PHALCON_CALL_METHODW(NULL, &dispatcher, "setnamespacename", &namespace_name); PHALCON_CALL_METHODW(NULL, &dispatcher, "settaskname", &task_name); PHALCON_CALL_METHODW(NULL, &dispatcher, "setactionname", &action_name); PHALCON_CALL_METHODW(NULL, &dispatcher, "setparams", ¶ms); if (Z_TYPE(events_manager) == IS_OBJECT) { ZVAL_STRING(&event_name, "console:beforeHandleTask"); PHALCON_CALL_METHODW(&status, &events_manager, "fire", &event_name, getThis(), &dispatcher); if (PHALCON_IS_FALSE(&status)) { RETURN_FALSE; } } PHALCON_CALL_METHODW(&status, &dispatcher, "dispatch"); if (Z_TYPE(events_manager) == IS_OBJECT) { ZVAL_STRING(&event_name, "console:afterHandleTask"); PHALCON_CALL_METHODW(NULL, &events_manager, "fire", &event_name, getThis(), &status); } RETURN_CTORW(&status); }
/** * Gets a variable from the $_REQUEST superglobal applying filters if needed. * If no parameters are given the $_REQUEST superglobal is returned * *<code> * //Returns value from $_REQUEST["user_email"] without sanitizing * $userEmail = $request->get("user_email"); * * //Returns value from $_REQUEST["user_email"] with sanitizing * $userEmail = $request->get("user_email", "email"); *</code> * * @param string $name * @param string|array $filters * @param mixed $defaultValue * @return mixed */ PHP_METHOD(Phalcon_Http_Request, get){ zval *name = NULL, *filters = NULL, *default_value = NULL, *request = NULL; zval *_REQUEST, *value, *filter = NULL, *dependency_injector; zval *service; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 3, &name, &filters, &default_value); if (!name) { PHALCON_INIT_VAR(name); } if (!filters) { PHALCON_INIT_VAR(filters); } if (!default_value) { PHALCON_INIT_VAR(default_value); } phalcon_get_global(&_REQUEST, SS("_REQUEST") TSRMLS_CC); PHALCON_CPY_WRT(request, _REQUEST); if (Z_TYPE_P(name) != IS_NULL) { if (phalcon_array_isset(request, name)) { PHALCON_OBS_VAR(value); phalcon_array_fetch(&value, request, name, PH_NOISY); if (Z_TYPE_P(filters) != IS_NULL) { PHALCON_OBS_VAR(filter); phalcon_read_property_this(&filter, this_ptr, SL("_filter"), PH_NOISY_CC); if (Z_TYPE_P(filter) != IS_OBJECT) { PHALCON_OBS_VAR(dependency_injector); phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_http_request_exception_ce, "A dependency injection object is required to access the 'filter' service"); return; } PHALCON_INIT_VAR(service); ZVAL_STRING(service, "filter", 1); PHALCON_INIT_NVAR(filter); phalcon_call_method_p1(filter, dependency_injector, "getshared", service); phalcon_update_property_this(this_ptr, SL("_filter"), filter TSRMLS_CC); } phalcon_call_method_p2(return_value, filter, "sanitize", value, filters); RETURN_MM(); } else { RETURN_CCTOR(value); } } RETURN_CCTOR(default_value); } RETURN_CCTOR(request); }
/** * Rpc call * * @param string $method * @param string $data * @return Phalcon\JsonRpc\Response */ PHP_METHOD(Phalcon_JsonRpc_Client, call){ zval *method = NULL, *data = NULL, *httpclient, *id, *jsonrpc_message, *json_message = NULL, *response = NULL; zval *code = NULL, *body = NULL, *json = NULL, *jsonrpc_response, *result, *error; int i; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &method, &data); httpclient = phalcon_fetch_nproperty_this(this_ptr, SL("_httpclient"), PH_NOISY TSRMLS_CC); id = phalcon_fetch_nproperty_this(this_ptr, SL("_id"), PH_NOISY TSRMLS_CC); i = Z_LVAL_P(id) + 1; ZVAL_LONG(id, i); phalcon_update_property_this(this_ptr, SL("_id"), id TSRMLS_CC); PHALCON_INIT_VAR(jsonrpc_message); array_init(jsonrpc_message); phalcon_array_update_string_string(&jsonrpc_message, SL("jsonrpc"), SL("2.0"), 0); phalcon_array_update_string(&jsonrpc_message, SL("method"), method, PH_COPY); if (data) { phalcon_array_update_string(&jsonrpc_message, SL("params"), data, PH_COPY); } phalcon_array_update_string(&jsonrpc_message, SL("id"), id, PH_COPY); PHALCON_CALL_FUNCTION(&json_message, "json_encode", jsonrpc_message); PHALCON_CALL_METHOD(NULL, httpclient, "setdata", json_message); PHALCON_CALL_METHOD(&response, httpclient, "post"); PHALCON_VERIFY_CLASS_EX(response, phalcon_http_client_response_ce, phalcon_jsonrpc_client_exception_ce, 1); PHALCON_CALL_METHOD(&code, response, "getstatuscode"); PHALCON_CALL_METHOD(&body, response, "getbody"); PHALCON_INIT_VAR(jsonrpc_response); object_init_ex(jsonrpc_response, phalcon_jsonrpc_client_response_ce); PHALCON_CALL_METHOD(NULL, jsonrpc_response, "__construct", body); PHALCON_CALL_METHOD(NULL, jsonrpc_response, "setcode", code); if (PHALCON_IS_NOT_EMPTY(body)) { PHALCON_CALL_FUNCTION(&json, "json_decode", body, PHALCON_GLOBAL(z_true)); if (Z_TYPE_P(json) == IS_ARRAY) { if (phalcon_array_isset_string(json, SS("id"))) { PHALCON_OBS_VAR(id); phalcon_array_fetch_string(&id, json, SL("id"), PH_NOISY); PHALCON_CALL_METHOD(NULL, jsonrpc_response, "setid", id); } if (phalcon_array_isset_string(json, SS("result"))) { PHALCON_OBS_VAR(result); phalcon_array_fetch_string(&result, json, SL("result"), PH_NOISY); PHALCON_CALL_METHOD(NULL, jsonrpc_response, "setresult", result); } if (phalcon_array_isset_string(json, SS("error"))) { PHALCON_OBS_VAR(error); phalcon_array_fetch_string(&error, json, SL("error"), PH_NOISY); PHALCON_CALL_METHOD(NULL, jsonrpc_response, "seterror", error); } } } RETURN_CTOR(jsonrpc_response); }