/** * Internal sanizite wrapper to filter_var * * @param mixed $value * @param string $filter * @return mixed */ PHP_METHOD(Phalcon_Filter, _sanitize){ zval *value, *filter, *filters, *filter_object; zval *arguments, *filtered = NULL, *type = NULL, *quote, *empty_str; zval *escaped, *allow_fraction, *options, *exception_message; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &value, &filter) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(filters); phalcon_read_property(&filters, this_ptr, SL("_filters"), PH_NOISY_CC); eval_int = phalcon_array_isset(filters, filter); if (eval_int) { PHALCON_INIT_VAR(filter_object); phalcon_array_fetch(&filter_object, filters, filter, PH_NOISY_CC); /** * If the filter is a closure we call it in the PHP userland */ if (phalcon_is_instance_of(filter_object, SL("Closure") TSRMLS_CC)) { PHALCON_INIT_VAR(arguments); array_init(arguments); phalcon_array_append(&arguments, value, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(filtered); PHALCON_CALL_USER_FUNC_ARRAY(filtered, filter_object, arguments); } else { PHALCON_INIT_NVAR(filtered); PHALCON_CALL_METHOD_PARAMS_1(filtered, filter_object, "filter", value, PH_NO_CHECK); } RETURN_CCTOR(filtered); } PHALCON_INIT_NVAR(filtered); if (PHALCON_COMPARE_STRING(filter, "email")) { /** * The 'email' filter uses the filter extension */ PHALCON_INIT_VAR(type); ZVAL_LONG(type, 517); PHALCON_INIT_VAR(quote); ZVAL_STRING(quote, "'", 1); PHALCON_INIT_VAR(empty_str); ZVAL_STRING(empty_str, "", 1); PHALCON_INIT_VAR(escaped); phalcon_fast_str_replace(escaped, quote, empty_str, value TSRMLS_CC); PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_2(filtered, "filter_var", escaped, type); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "int")) { /** * 'int' filter sanitizes a numeric input */ PHALCON_INIT_NVAR(type); ZVAL_LONG(type, 519); PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_2(filtered, "filter_var", value, type); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "string")) { PHALCON_INIT_NVAR(type); ZVAL_LONG(type, 513); PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_2(filtered, "filter_var", value, type); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "float")) { /** * The 'float' filter uses the filter extension */ PHALCON_INIT_VAR(allow_fraction); ZVAL_LONG(allow_fraction, 4096); PHALCON_INIT_VAR(options); array_init(options); phalcon_array_update_string(&options, SL("flags"), &allow_fraction, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(type); ZVAL_LONG(type, 520); PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_3(filtered, "filter_var", value, type, options); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "alphanum")) { PHALCON_INIT_NVAR(filtered); phalcon_filter_alphanum(filtered, value); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "trim")) { PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "trim", value); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "striptags")) { PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "strip_tags", value); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "lower")) { if (phalcon_function_exists_ex(SS("mb_strtolower") TSRMLS_CC) == SUCCESS) { /** * 'lower' checks for the mbstring extension to make a correct lowercase * transformation */ PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "mb_strtolower", value); } else { PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "strtolower", value); } goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "upper")) { if (phalcon_function_exists_ex(SS("mb_strtoupper") TSRMLS_CC) == SUCCESS) { /** * 'upper' checks for the mbstring extension to make a correct lowercase * transformation */ PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "mb_strtoupper", value); } else { PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "strtoupper", value); } goto ph_end_0; } PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Sanitize filter ", filter, " is not supported"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_filter_exception_ce, exception_message); return; ph_end_0: RETURN_CCTOR(filtered); }
/** * Resolves the service * * @param array $parameters * @param Phalcon\DiInterface $dependencyInjector * @return mixed */ PHP_METHOD(Phalcon_DI_Service, resolve){ zval *parameters = NULL, *dependency_injector = NULL, *shared; zval *shared_instance, *found = NULL, *instance = NULL, *definition; zval *builder, *name, *exception_message; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 2, ¶meters, &dependency_injector); if (!parameters) { PHALCON_INIT_VAR(parameters); } if (!dependency_injector) { PHALCON_INIT_VAR(dependency_injector); } PHALCON_OBS_VAR(shared); phalcon_read_property_this(&shared, this_ptr, SL("_shared"), PH_NOISY_CC); /** * Check if the service is shared */ if (zend_is_true(shared)) { PHALCON_OBS_VAR(shared_instance); phalcon_read_property_this(&shared_instance, this_ptr, SL("_sharedInstance"), PH_NOISY_CC); if (Z_TYPE_P(shared_instance) != IS_NULL) { RETURN_CCTOR(shared_instance); } } PHALCON_INIT_VAR(found); ZVAL_BOOL(found, 1); PHALCON_INIT_VAR(instance); PHALCON_OBS_VAR(definition); phalcon_read_property_this(&definition, this_ptr, SL("_definition"), PH_NOISY_CC); if (Z_TYPE_P(definition) == IS_STRING) { /** * String definitions can be class names without implicit parameters */ if (phalcon_class_exists(definition, 1 TSRMLS_CC)) { if (Z_TYPE_P(parameters) == IS_ARRAY) { if (phalcon_fast_count_ev(parameters TSRMLS_CC)) { if (phalcon_create_instance_params(instance, definition, parameters TSRMLS_CC) == FAILURE) { return; } } else { PHALCON_INIT_NVAR(instance); if (phalcon_create_instance(instance, definition TSRMLS_CC) == FAILURE) { return; } } } else { PHALCON_INIT_NVAR(instance); if (phalcon_create_instance(instance, definition TSRMLS_CC) == FAILURE) { return; } } } else { ZVAL_BOOL(found, 0); } } else { /** * Object definitions can be a Closure or an already resolved instance */ if (likely(Z_TYPE_P(definition) == IS_OBJECT)) { if (phalcon_is_instance_of(definition, SL("Closure") TSRMLS_CC)) { if (Z_TYPE_P(parameters) == IS_ARRAY) { PHALCON_INIT_NVAR(instance); PHALCON_CALL_USER_FUNC_ARRAY(instance, definition, parameters); } else { PHALCON_INIT_NVAR(instance); PHALCON_CALL_USER_FUNC(instance, definition); } } else { PHALCON_CPY_WRT(instance, definition); } } else { /** * Array definitions require a 'className' parameter */ if (Z_TYPE_P(definition) == IS_ARRAY) { PHALCON_INIT_VAR(builder); object_init_ex(builder, phalcon_di_service_builder_ce); PHALCON_INIT_NVAR(instance); phalcon_call_method_p3(instance, builder, "build", dependency_injector, definition, parameters); } else { PHALCON_INIT_NVAR(found); ZVAL_BOOL(found, 0); } } } /** * If the service can't be built, we must throw an exception */ if (PHALCON_IS_FALSE(found)) { PHALCON_OBS_VAR(name); phalcon_read_property_this(&name, this_ptr, SL("_name"), PH_NOISY_CC); PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Service '", name, "' cannot be resolved"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_di_exception_ce, exception_message); return; } /** * Update the shared instance if the service is shared */ if (zend_is_true(shared)) { phalcon_update_property_this(this_ptr, SL("_sharedInstance"), instance TSRMLS_CC); } RETURN_CCTOR(instance); }
/** * 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_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_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_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_p2_noret(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 (phalcon_is_instance_of(engine_service, SL("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_INIT_NVAR(engine_object); phalcon_call_method_p2(engine_object, dependency_injector, "getshared", engine_service, arguments); } 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_CC); } RETURN_CCTOR(engines); }
/** * Internal handler to call a queue of events * * @param \SplPriorityQueue $queue * @param Phalcon\Events\Event $event * @return mixed */ PHP_METHOD(Phalcon_Events_Manager, fireQueue){ zval *queue, *event, *status = NULL, *arguments = NULL, *event_name; zval *source, *data, *cancelable, *collect, *iterator; zval *handler = NULL, *is_stopped = NULL; zval *r0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &queue, &event); if (unlikely(Z_TYPE_P(queue) != IS_ARRAY)) { if (Z_TYPE_P(queue) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_events_exception_ce, "The SplPriorityQueue is not valid"); return; } } if (unlikely(Z_TYPE_P(event) != IS_OBJECT)) { PHALCON_THROW_EXCEPTION_STR(phalcon_events_exception_ce, "The event is not valid"); return; } PHALCON_INIT_VAR(status); PHALCON_INIT_VAR(arguments); /** * Get the event type */ PHALCON_INIT_VAR(event_name); phalcon_call_method(event_name, event, "gettype"); if (unlikely(Z_TYPE_P(event_name) != IS_STRING)) { PHALCON_THROW_EXCEPTION_STR(phalcon_events_exception_ce, "The event type not valid"); return; } /** * Get the object who triggered the event */ PHALCON_INIT_VAR(source); phalcon_call_method(source, event, "getsource"); /** * Get extra data passed to the event */ PHALCON_INIT_VAR(data); phalcon_call_method(data, event, "getdata"); /** * Tell if the event is cancelable */ PHALCON_INIT_VAR(cancelable); phalcon_call_method(cancelable, event, "getcancelable"); /** * Responses need to be traced? */ PHALCON_OBS_VAR(collect); phalcon_read_property_this(&collect, this_ptr, SL("_collect"), PH_NOISY_CC); if (Z_TYPE_P(queue) == IS_OBJECT) { /** * We need to clone the queue before iterate over it */ PHALCON_INIT_VAR(iterator); if (phalcon_clone(iterator, queue TSRMLS_CC) == FAILURE) { return; } /** * Move the queue to the top */ phalcon_call_method_noret(iterator, "top"); while (1) { PHALCON_INIT_NVAR(r0); phalcon_call_method(r0, iterator, "valid"); if (zend_is_true(r0)) { } else { break; } /** * Get the current data */ PHALCON_INIT_NVAR(handler); phalcon_call_method(handler, iterator, "current"); /** * Only handler objects are valid */ if (likely(Z_TYPE_P(handler) == IS_OBJECT)) { /** * Check if the event is a closure */ if (phalcon_is_instance_of(handler, SL("Closure") TSRMLS_CC)) { /** * Create the closure arguments */ if (Z_TYPE_P(arguments) == IS_NULL) { PHALCON_INIT_NVAR(arguments); array_init_size(arguments, 3); phalcon_array_append(&arguments, event, PH_SEPARATE); phalcon_array_append(&arguments, source, PH_SEPARATE); phalcon_array_append(&arguments, data, PH_SEPARATE); } /** * Call the function in the PHP userland */ PHALCON_INIT_NVAR(status); PHALCON_CALL_USER_FUNC_ARRAY(status, handler, arguments); /** * Trace the response */ if (zend_is_true(collect)) { phalcon_update_property_array_append(this_ptr, SL("_responses"), status TSRMLS_CC); } if (zend_is_true(cancelable)) { /** * Check if the event was stopped by the user */ PHALCON_INIT_NVAR(is_stopped); phalcon_call_method(is_stopped, event, "isstopped"); if (zend_is_true(is_stopped)) { break; } } } else { /** * Check if the listener has implemented an event with the same name */ if (phalcon_method_exists(handler, event_name TSRMLS_CC) == SUCCESS) { /** * Call the function in the PHP userland */ PHALCON_INIT_NVAR(status); phalcon_call_method_zval_p3(status, handler, event_name, event, source, data); /** * Collect the response */ if (zend_is_true(collect)) { phalcon_update_property_array_append(this_ptr, SL("_responses"), status TSRMLS_CC); } if (zend_is_true(cancelable)) { /** * Check if the event was stopped by the user */ PHALCON_INIT_NVAR(is_stopped); phalcon_call_method(is_stopped, event, "isstopped"); if (zend_is_true(is_stopped)) { break; } } } } } /** * Move the queue to the next handler */ phalcon_call_method_noret(iterator, "next"); } } else { phalcon_is_iterable(queue, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(handler); /** * Only handler objects are valid */ if (likely(Z_TYPE_P(handler) == IS_OBJECT)) { /** * Check if the event is a closure */ if (phalcon_is_instance_of(handler, SL("Closure") TSRMLS_CC)) { /** * Create the closure arguments */ if (Z_TYPE_P(arguments) == IS_NULL) { PHALCON_INIT_NVAR(arguments); array_init_size(arguments, 3); phalcon_array_append(&arguments, event, PH_SEPARATE); phalcon_array_append(&arguments, source, PH_SEPARATE); phalcon_array_append(&arguments, data, PH_SEPARATE); } /** * Call the function in the PHP userland */ PHALCON_INIT_NVAR(status); PHALCON_CALL_USER_FUNC_ARRAY(status, handler, arguments); /** * Trace the response */ if (zend_is_true(collect)) { phalcon_update_property_array_append(this_ptr, SL("_responses"), status TSRMLS_CC); } if (zend_is_true(cancelable)) { /** * Check if the event was stopped by the user */ PHALCON_INIT_NVAR(is_stopped); phalcon_call_method(is_stopped, event, "isstopped"); if (zend_is_true(is_stopped)) { break; } } } else { /** * Check if the listener has implemented an event with the same name */ if (phalcon_method_exists(handler, event_name TSRMLS_CC) == SUCCESS) { /** * Call the function in the PHP userland */ PHALCON_INIT_NVAR(status); phalcon_call_method_zval_p3(status, handler, event_name, event, source, data); /** * Collect the response */ if (zend_is_true(collect)) { phalcon_update_property_array_append(this_ptr, SL("_responses"), status TSRMLS_CC); } if (zend_is_true(cancelable)) { /** * Check if the event was stopped by the user */ PHALCON_INIT_NVAR(is_stopped); phalcon_call_method(is_stopped, event, "isstopped"); if (zend_is_true(is_stopped)) { break; } } } } } zend_hash_move_forward_ex(ah0, &hp0); } } RETURN_CCTOR(status); }
/** * Listens for notifications from the models manager * * @param string $type * @param Phalcon\Mvc\ModelInterface $model */ PHP_METHOD(Phalcon_Mvc_Model_Behavior_Timestampable, notify){ zval *type, *model, *take_action, *options, *timestamp = NULL; zval *format, *generator, *field, *single_field = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &type, &model); /** * Check if the developer decided to take action here */ PHALCON_INIT_VAR(take_action); phalcon_call_method_p1(take_action, this_ptr, "musttakeaction", type); if (PHALCON_IS_NOT_TRUE(take_action)) { RETURN_MM_NULL(); } PHALCON_INIT_VAR(options); phalcon_call_method_p1(options, this_ptr, "getoptions", type); if (Z_TYPE_P(options) == IS_ARRAY) { /** * The field name is required in this behavior */ if (!phalcon_array_isset_string(options, SS("field"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "The option 'field' is required"); return; } PHALCON_INIT_VAR(timestamp); if (phalcon_array_isset_string(options, SS("format"))) { /** * Format is a format for date() */ PHALCON_OBS_VAR(format); phalcon_array_fetch_string(&format, options, SL("format"), PH_NOISY_CC); phalcon_call_func_p1(timestamp, "date", format); } else { if (phalcon_array_isset_string(options, SS("generator"))) { /** * A generator is a closure that produce the correct timestamp value */ PHALCON_OBS_VAR(generator); phalcon_array_fetch_string(&generator, options, SL("generator"), PH_NOISY_CC); if (Z_TYPE_P(generator) == IS_OBJECT) { if (phalcon_is_instance_of(generator, SL("Closure") TSRMLS_CC)) { PHALCON_INIT_NVAR(timestamp); PHALCON_CALL_USER_FUNC(timestamp, generator); } } } } /** * Last resort call time() */ if (Z_TYPE_P(timestamp) == IS_NULL) { PHALCON_INIT_NVAR(timestamp); ZVAL_LONG(timestamp, (long) time(NULL)); } PHALCON_OBS_VAR(field); phalcon_array_fetch_string(&field, options, SL("field"), PH_NOISY_CC); /** * Assign the value to the field, use writeattribute if the property is protected */ if (unlikely(Z_TYPE_P(field) == IS_ARRAY)) { phalcon_is_iterable(field, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(single_field); phalcon_call_method_p2_noret(model, "writeattribute", single_field, timestamp); zend_hash_move_forward_ex(ah0, &hp0); } } else { phalcon_call_method_p2_noret(model, "writeattribute", field, timestamp); } } PHALCON_MM_RESTORE(); }
/** * Fires a event in the events manager causing that the acive listeners will be notified about it * * @param string $eventType * @param object $source * @param mixed $data * @return mixed */ PHP_METHOD(Phalcon_Events_Manager, fire){ zval *event_type, *source, *data = NULL, *events, *exception_message; zval *colon, *event_parts, *type, *event_name, *status = NULL; zval *fire_events = NULL, *handler = NULL, *event = NULL, *arguments = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &event_type, &source, &data) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!data) { PHALCON_INIT_NVAR(data); } if (Z_TYPE_P(event_type) != IS_STRING) { PHALCON_THROW_EXCEPTION_STR(phalcon_events_exception_ce, "Event type must be a string"); return; } PHALCON_INIT_VAR(events); phalcon_read_property(&events, this_ptr, SL("_events"), PH_NOISY_CC); if (Z_TYPE_P(events) != IS_ARRAY) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!phalcon_memnstr_str(event_type, SL(":") TSRMLS_CC)) { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SV(exception_message, "Invalid event type ", event_type); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_events_exception_ce, exception_message); return; } PHALCON_INIT_VAR(colon); ZVAL_STRING(colon, ":", 1); PHALCON_INIT_VAR(event_parts); phalcon_fast_explode(event_parts, colon, event_type TSRMLS_CC); PHALCON_INIT_VAR(type); phalcon_array_fetch_long(&type, event_parts, 0, PH_NOISY_CC); PHALCON_INIT_VAR(event_name); phalcon_array_fetch_long(&event_name, event_parts, 1, PH_NOISY_CC); PHALCON_INIT_VAR(status); eval_int = phalcon_array_isset(events, type); if (eval_int) { PHALCON_INIT_VAR(fire_events); phalcon_array_fetch(&fire_events, events, type, PH_NOISY_CC); if (Z_TYPE_P(fire_events) == IS_ARRAY) { if (!phalcon_valid_foreach(fire_events TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(fire_events); zend_hash_internal_pointer_reset_ex(ah0, &hp0); ph_cycle_start_0: if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) { goto ph_cycle_end_0; } PHALCON_GET_FOREACH_VALUE(handler); if (Z_TYPE_P(handler) == IS_OBJECT) { if (phalcon_is_instance_of(handler, SL("Closure") TSRMLS_CC)) { PHALCON_INIT_NVAR(event); object_init_ex(event, phalcon_events_event_ce); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(event, "__construct", event_name, source, data, PH_CHECK); PHALCON_INIT_NVAR(arguments); array_init(arguments); phalcon_array_append(&arguments, event, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&arguments, source, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&arguments, data, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(status); PHALCON_CALL_USER_FUNC_ARRAY(status, handler, arguments); } else { if (phalcon_method_exists(handler, event_name TSRMLS_CC) == SUCCESS) { PHALCON_INIT_NVAR(event); object_init_ex(event, phalcon_events_event_ce); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(event, "__construct", event_name, source, data, PH_CHECK); PHALCON_INIT_NVAR(status); PHALCON_CALL_METHOD_PARAMS_3(status, handler, Z_STRVAL_P(event_name), event, source, data, PH_NO_CHECK); } } } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: if(0){} } } eval_int = phalcon_array_isset(events, event_type); if (eval_int) { PHALCON_INIT_NVAR(fire_events); phalcon_array_fetch(&fire_events, events, event_type, PH_NOISY_CC); if (Z_TYPE_P(fire_events) == IS_ARRAY) { if (!phalcon_valid_foreach(fire_events TSRMLS_CC)) { return; } ah1 = Z_ARRVAL_P(fire_events); zend_hash_internal_pointer_reset_ex(ah1, &hp1); ph_cycle_start_1: if (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS) { goto ph_cycle_end_1; } PHALCON_GET_FOREACH_VALUE(handler); if (Z_TYPE_P(handler) == IS_OBJECT) { if (phalcon_is_instance_of(handler, SL("Closure") TSRMLS_CC)) { PHALCON_INIT_NVAR(event); object_init_ex(event, phalcon_events_event_ce); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(event, "__construct", event_name, source, data, PH_CHECK); PHALCON_INIT_NVAR(arguments); array_init(arguments); phalcon_array_append(&arguments, event, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&arguments, source, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&arguments, data, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(status); PHALCON_CALL_USER_FUNC_ARRAY(status, handler, arguments); } else { if (phalcon_method_exists(handler, event_name TSRMLS_CC) == SUCCESS) { PHALCON_INIT_NVAR(event); object_init_ex(event, phalcon_events_event_ce); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(event, "__construct", event_name, source, data, PH_CHECK); PHALCON_INIT_NVAR(status); PHALCON_CALL_METHOD_PARAMS_3(status, handler, Z_STRVAL_P(event_name), event, source, data, PH_NO_CHECK); } } } zend_hash_move_forward_ex(ah1, &hp1); goto ph_cycle_start_1; ph_cycle_end_1: if(0){} } } RETURN_CCTOR(status); }
/** * Handles a MVC request * * @param string $uri * @return Phalcon\Http\ResponseInterface */ PHP_METHOD(Phalcon_Mvc_Application, handle){ zval *uri = NULL, *dependency_injector, *events_manager; zval *event_name = NULL, *status = NULL, *service = NULL, *router, *module_name = NULL; zval *module_object = NULL, *modules, *exception_msg = NULL; zval *module, *class_name = NULL, *path, *module_params; zval *implicit_view, *view, *namespace_name; zval *controller_name = NULL, *action_name = NULL, *params = NULL; zval *dispatcher, *controller, *returned_response = NULL; zval *possible_response, *render_status = NULL, *response = NULL; zval *content; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, &uri); if (!uri) { PHALCON_INIT_VAR(uri); } 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_mvc_application_exception_ce, "A dependency injection object is required to access internal services"); return; } PHALCON_OBS_VAR(events_manager); phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); /** * Call boot event, this allow the developer to perform initialization actions */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_VAR(event_name); ZVAL_STRING(event_name, "application:boot", 1); PHALCON_INIT_VAR(status); phalcon_call_method_p2(status, events_manager, "fire", event_name, this_ptr); if (PHALCON_IS_FALSE(status)) { RETURN_MM_FALSE; } } PHALCON_INIT_VAR(service); ZVAL_STRING(service, "router", 1); PHALCON_INIT_VAR(router); phalcon_call_method_p1(router, dependency_injector, "getshared", service); /** * Handle the URI pattern (if any) */ phalcon_call_method_p1_noret(router, "handle", uri); /** * Load module config */ PHALCON_INIT_VAR(module_name); 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)) { PHALCON_OBS_NVAR(module_name); phalcon_read_property_this(&module_name, this_ptr, SL("_defaultModule"), PH_NOISY_CC); } PHALCON_INIT_VAR(module_object); /** * Process the module definition */ if (zend_is_true(module_name)) { if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "application:beforeStartModule", 1); PHALCON_INIT_NVAR(status); phalcon_call_method_p3(status, events_manager, "fire", event_name, this_ptr, module_name); if (PHALCON_IS_FALSE(status)) { RETURN_MM_FALSE; } } /** * Check if the module passed by the router is registered in the modules container */ PHALCON_OBS_VAR(modules); phalcon_read_property_this(&modules, this_ptr, SL("_modules"), PH_NOISY_CC); if (!phalcon_array_isset(modules, module_name)) { PHALCON_INIT_VAR(exception_msg); PHALCON_CONCAT_SVS(exception_msg, "Module '", module_name, "' isn't registered in the application container"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_application_exception_ce, exception_msg); return; } /** * A module definition must ne an array or an object */ PHALCON_OBS_VAR(module); phalcon_array_fetch(&module, modules, module_name, PH_NOISY); if (Z_TYPE_P(module) != IS_ARRAY) { if (Z_TYPE_P(module) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_application_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_string(module, SS("className"))) { PHALCON_OBS_VAR(class_name); phalcon_array_fetch_string(&class_name, module, SL("className"), PH_NOISY); } else { PHALCON_INIT_NVAR(class_name); ZVAL_STRING(class_name, "Module", 1); } /** * If developer specify a path try to include the file */ if (phalcon_array_isset_string(module, SS("path"))) { PHALCON_OBS_VAR(path); phalcon_array_fetch_string(&path, module, SL("path"), PH_NOISY); if (!phalcon_class_exists(class_name, 0 TSRMLS_CC)) { if (phalcon_file_exists(path TSRMLS_CC) == SUCCESS) { if (phalcon_require(path TSRMLS_CC) == FAILURE) { return; } } else { PHALCON_INIT_NVAR(exception_msg); PHALCON_CONCAT_SVS(exception_msg, "Module definition path '", path, "' doesn't exist"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_application_exception_ce, exception_msg); return; } } } phalcon_call_method_p1(module_object, dependency_injector, "get", class_name); /** * 'registerAutoloaders' and 'registerServices' are automatically called */ phalcon_call_method_p1_noret(module_object, "registerautoloaders", dependency_injector); phalcon_call_method_p1_noret(module_object, "registerservices", dependency_injector); } else { /** * A module definition object, can be a Closure instance */ if (phalcon_is_instance_of(module, SL("Closure") TSRMLS_CC)) { PHALCON_INIT_VAR(module_params); array_init_size(module_params, 1); phalcon_array_append(&module_params, dependency_injector, PH_SEPARATE); PHALCON_INIT_NVAR(status); PHALCON_CALL_USER_FUNC_ARRAY(status, module, module_params); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_application_exception_ce, "Invalid module definition"); return; } } /** * Calling afterStartModule event */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { phalcon_update_property_this(this_ptr, SL("_moduleObject"), module_object TSRMLS_CC); PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "application:afterStartModule", 1); PHALCON_INIT_NVAR(status); phalcon_call_method_p3(status, events_manager, "fire", event_name, this_ptr, module_name); if (PHALCON_IS_FALSE(status)) { RETURN_MM_FALSE; } } } /** * Check whether use implicit views or not */ PHALCON_OBS_VAR(implicit_view); phalcon_read_property_this(&implicit_view, this_ptr, SL("_implicitView"), PH_NOISY_CC); if (PHALCON_IS_TRUE(implicit_view)) { PHALCON_INIT_NVAR(service); ZVAL_STRING(service, "view", 1); PHALCON_INIT_VAR(view); phalcon_call_method_p1(view, dependency_injector, "getshared", service); } /** * We get the parameters from the router and assign them to the dispatcher */ PHALCON_INIT_NVAR(module_name); phalcon_call_method(module_name, router, "getmodulename"); PHALCON_INIT_VAR(namespace_name); phalcon_call_method(namespace_name, router, "getnamespacename"); PHALCON_INIT_VAR(controller_name); phalcon_call_method(controller_name, router, "getcontrollername"); PHALCON_INIT_VAR(action_name); phalcon_call_method(action_name, router, "getactionname"); PHALCON_INIT_VAR(params); phalcon_call_method(params, router, "getparams"); PHALCON_INIT_NVAR(service); ZVAL_STRING(service, "dispatcher", 1); PHALCON_INIT_VAR(dispatcher); phalcon_call_method_p1(dispatcher, dependency_injector, "getshared", service); /** * Assign the values passed from the router */ phalcon_call_method_p1_noret(dispatcher, "setmodulename", module_name); phalcon_call_method_p1_noret(dispatcher, "setnamespacename", namespace_name); phalcon_call_method_p1_noret(dispatcher, "setcontrollername", controller_name); phalcon_call_method_p1_noret(dispatcher, "setactionname", action_name); phalcon_call_method_p1_noret(dispatcher, "setparams", params); /** * Start the view component (start output buffering) */ if (PHALCON_IS_TRUE(implicit_view)) { phalcon_call_method_noret(view, "start"); } /** * Calling beforeHandleRequest */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "application:beforeHandleRequest", 1); PHALCON_INIT_NVAR(status); phalcon_call_method_p3(status, events_manager, "fire", event_name, this_ptr, dispatcher); if (PHALCON_IS_FALSE(status)) { RETURN_MM_FALSE; } } /** * The dispatcher must return an object */ PHALCON_INIT_VAR(controller); phalcon_call_method(controller, dispatcher, "dispatch"); PHALCON_INIT_VAR(returned_response); ZVAL_BOOL(returned_response, 0); /** * Get the latest value returned by an action */ PHALCON_INIT_VAR(possible_response); phalcon_call_method(possible_response, dispatcher, "getreturnedvalue"); if (Z_TYPE_P(possible_response) == IS_OBJECT) { /** * Check if the returned object is already a response */ phalcon_instance_of(returned_response, possible_response, phalcon_http_responseinterface_ce TSRMLS_CC); } /** * Calling afterHandleRequest */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "application:afterHandleRequest", 1); phalcon_call_method_p3_noret(events_manager, "fire", event_name, this_ptr, controller); } /** * If the dispatcher returns an object we try to render the view in auto-rendering * mode */ if (PHALCON_IS_FALSE(returned_response)) { if (PHALCON_IS_TRUE(implicit_view)) { if (Z_TYPE_P(controller) == IS_OBJECT) { PHALCON_INIT_VAR(render_status); ZVAL_BOOL(render_status, 1); /** * This allows to make a custom view render */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "application:viewRender", 1); phalcon_call_method_p3(render_status, events_manager, "fire", event_name, this_ptr, view); } /** * Check if the view process has been treated by the developer */ if (PHALCON_IS_NOT_FALSE(render_status)) { PHALCON_INIT_NVAR(controller_name); phalcon_call_method(controller_name, dispatcher, "getcontrollername"); PHALCON_INIT_NVAR(action_name); phalcon_call_method(action_name, dispatcher, "getactionname"); PHALCON_INIT_NVAR(params); phalcon_call_method(params, dispatcher, "getparams"); /** * Automatic render based on the latest controller executed */ phalcon_call_method_p3_noret(view, "render", controller_name, action_name, params); } } } } /** * Finish the view component (stop output buffering) */ if (PHALCON_IS_TRUE(implicit_view)) { phalcon_call_method_noret(view, "finish"); } if (PHALCON_IS_FALSE(returned_response)) { PHALCON_INIT_NVAR(service); ZVAL_STRING(service, "response", 1); PHALCON_INIT_VAR(response); phalcon_call_method_p1(response, dependency_injector, "getshared", service); if (PHALCON_IS_TRUE(implicit_view)) { /** * The content returned by the view is passed to the response service */ PHALCON_INIT_VAR(content); phalcon_call_method(content, view, "getcontent"); phalcon_call_method_p1_noret(response, "setcontent", content); } } else { /** * We don't need to create a response because there is a one already created */ PHALCON_CPY_WRT(response, possible_response); } /** * Calling beforeSendResponse */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "application:beforeSendResponse", 1); phalcon_call_method_p3_noret(events_manager, "fire", event_name, this_ptr, response); } /** * Headers are automatically send */ phalcon_call_method_noret(response, "sendheaders"); /** * Cookies are automatically send */ phalcon_call_method_noret(response, "sendcookies"); /** * Return the response */ RETURN_CCTOR(response); }