/** * Attempts to register a service in the services container * Only is successful if a service hasn't been registered previously * with the same name * * @param string $name * @param mixed $definition * @param boolean $shared * @return Phalcon\DI\ServiceInterface */ PHP_METHOD(Phalcon_DI, attempt){ zval *name, *definition, *shared = NULL, *services, *service; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 1, &name, &definition, &shared); if (!shared) { PHALCON_INIT_VAR(shared); ZVAL_BOOL(shared, 0); } if (Z_TYPE_P(name) != IS_STRING) { PHALCON_THROW_EXCEPTION_STR(phalcon_di_exception_ce, "The service name must be a string"); return; } PHALCON_OBS_VAR(services); phalcon_read_property_this(&services, this_ptr, SL("_services"), PH_NOISY_CC); if (!phalcon_array_isset(services, name)) { PHALCON_INIT_VAR(service); object_init_ex(service, phalcon_di_service_ce); phalcon_call_method_p3_noret(service, "__construct", name, definition, shared); phalcon_update_property_array(this_ptr, SL("_services"), name, service TSRMLS_CC); RETURN_CTOR(service); } RETURN_MM_NULL(); }
/** * Executes the validation * * @param Phalcon\Validation $validator * @param string $attribute * @return boolean */ PHP_METHOD(Phalcon_Validation_Validator_ExclusionIn, validate){ zval *validator, *attribute, *value, *option = NULL, *domain; zval *message_str = NULL, *joined_domain, *type, *message; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &validator, &attribute); PHALCON_INIT_VAR(value); phalcon_call_method_p1(value, validator, "getvalue", attribute); /** * A domain is an array with a list of valid values */ PHALCON_INIT_VAR(option); ZVAL_STRING(option, "domain", 1); PHALCON_INIT_VAR(domain); phalcon_call_method_p1(domain, this_ptr, "getoption", option); if (Z_TYPE_P(domain) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "Option 'domain' must be an array"); return; } /** * Check if the value is contained by the array */ if (phalcon_fast_in_array(value, domain TSRMLS_CC)) { PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "message", 1); PHALCON_INIT_VAR(message_str); phalcon_call_method_p1(message_str, this_ptr, "getoption", option); if (!zend_is_true(message_str)) { PHALCON_INIT_VAR(joined_domain); phalcon_fast_join_str(joined_domain, SL(", "), domain TSRMLS_CC); PHALCON_INIT_NVAR(message_str); PHALCON_CONCAT_SVSV(message_str, "Value of field '", attribute, "' must not be part of list: ", joined_domain); } PHALCON_INIT_VAR(type); ZVAL_STRING(type, "ExclusionIn", 1); PHALCON_INIT_VAR(message); object_init_ex(message, phalcon_validation_message_ce); phalcon_call_method_p3_noret(message, "__construct", message_str, attribute, type); phalcon_call_method_p1_noret(validator, "appendmessage", message); RETURN_MM_FALSE; } RETURN_MM_TRUE; }
/** * Executes the validation * * @param Phalcon\Validation $validator * @param string $attribute * @return boolean */ PHP_METHOD(Phalcon_Validation_Validator_Between, validate){ zval *validator, *attribute, *value, *option = NULL, *minimum; zval *maximum, *valid = NULL, *type, *message_str = NULL, *message; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &validator, &attribute); PHALCON_INIT_VAR(value); phalcon_call_method_p1(value, validator, "getvalue", attribute); PHALCON_INIT_VAR(option); ZVAL_STRING(option, "minimum", 1); PHALCON_INIT_VAR(minimum); phalcon_call_method_p1(minimum, this_ptr, "getoption", option); PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "maximum", 1); PHALCON_INIT_VAR(maximum); phalcon_call_method_p1(maximum, this_ptr, "getoption", option); PHALCON_INIT_VAR(valid); is_smaller_or_equal_function(valid, minimum, value TSRMLS_CC); if (zend_is_true(valid)) { is_smaller_or_equal_function(valid, value, maximum TSRMLS_CC); } if (PHALCON_IS_FALSE(valid)) { PHALCON_INIT_VAR(type); ZVAL_STRING(type, "Between", 1); PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "message", 1); PHALCON_INIT_VAR(message_str); phalcon_call_method_p1(message_str, this_ptr, "getoption", option); if (!zend_is_true(message_str)) { PHALCON_INIT_NVAR(message_str); PHALCON_CONCAT_VS(message_str, attribute, " is not between a valid range"); } PHALCON_INIT_VAR(message); object_init_ex(message, phalcon_validation_message_ce); phalcon_call_method_p3_noret(message, "__construct", message_str, attribute, type); phalcon_call_method_p1_noret(validator, "appendmessage", message); RETURN_MM_FALSE; } RETURN_MM_TRUE; }
/** * Executes the validator * * @param Phalcon\Mvc\ModelInterface $record * @return boolean */ PHP_METHOD(Phalcon_Mvc_Model_Validator_Url, validate){ zval *record, *option = NULL, *field, *value, *flag, *is_valid; zval *message = NULL, *type; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &record); PHALCON_INIT_VAR(option); ZVAL_STRING(option, "field", 1); PHALCON_INIT_VAR(field); phalcon_call_method_p1(field, this_ptr, "getoption", option); if (Z_TYPE_P(field) != IS_STRING) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Field name must be a string"); return; } PHALCON_INIT_VAR(value); phalcon_call_method_p1(value, record, "readattribute", field); PHALCON_INIT_VAR(flag); ZVAL_LONG(flag, 273); /** * Filters the format using FILTER_VALIDATE_URL */ PHALCON_INIT_VAR(is_valid); phalcon_call_func_p2(is_valid, "filter_var", value, flag); if (!zend_is_true(is_valid)) { /** * Check if the developer has defined a custom message */ PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "message", 1); PHALCON_INIT_VAR(message); phalcon_call_method_p1(message, this_ptr, "getoption", option); if (!zend_is_true(message)) { PHALCON_INIT_NVAR(message); PHALCON_CONCAT_SVS(message, "'", field, "' does not have a valid url format"); } PHALCON_INIT_VAR(type); ZVAL_STRING(type, "Url", 1); phalcon_call_method_p3_noret(this_ptr, "appendmessage", message, field, type); RETURN_MM_FALSE; } RETURN_MM_TRUE; }
/** * Executes the validator * * @param Phalcon\Mvc\ModelInterface $record * @return boolean */ PHP_METHOD(Phalcon_Mvc_Model_Validator_Numericality, validate){ zval *record, *option = NULL, *field, *value, *message = NULL, *type; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &record); PHALCON_INIT_VAR(option); ZVAL_STRING(option, "field", 1); PHALCON_INIT_VAR(field); phalcon_call_method_p1(field, this_ptr, "getoption", option); if (Z_TYPE_P(field) != IS_STRING) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Field name must be a string"); return; } PHALCON_INIT_VAR(value); phalcon_call_method_p1(value, record, "readattribute", field); /** * Check if the value is numeric using is_numeric in the PHP userland */ if (!phalcon_is_numeric(value)) { /** * Check if the developer has defined a custom message */ PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "message", 1); PHALCON_INIT_VAR(message); phalcon_call_method_p1(message, this_ptr, "getoption", option); if (!zend_is_true(message)) { PHALCON_INIT_NVAR(message); PHALCON_CONCAT_SVS(message, "Value of field '", field, "' must be numeric"); } PHALCON_INIT_VAR(type); ZVAL_STRING(type, "Numericality", 1); phalcon_call_method_p3_noret(this_ptr, "appendmessage", message, field, type); RETURN_MM_FALSE; } RETURN_MM_TRUE; }
/** * Appends a condition to the current conditions using an AND operator (deprecated) * * @param string $conditions * @param array $bindParams * @param array $bindTypes * @return Phalcon\Mvc\Model\Criteria */ PHP_METHOD(Phalcon_Mvc_Model_Criteria, addWhere){ zval *conditions, *bind_params = NULL, *bind_types = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 2, &conditions, &bind_params, &bind_types); if (!bind_params) { PHALCON_INIT_VAR(bind_params); } if (!bind_types) { PHALCON_INIT_VAR(bind_types); } phalcon_call_method_p3_noret(this_ptr, "andwhere", conditions, bind_params, bind_types); RETURN_THIS(); }
/** * Appends a message to the validator * * @param string $message * @param string $field * @param string $type */ PHP_METHOD(Phalcon_Mvc_Model_Validator, appendMessage){ zval *message, *field = NULL, *type = NULL, *class_name, *suffix; zval *empty_string, *model_message; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 2, &message, &field, &type); if (!field) { PHALCON_INIT_VAR(field); } if (!type) { PHALCON_INIT_VAR(type); } else { PHALCON_SEPARATE_PARAM(type); } if (!zend_is_true(type)) { PHALCON_INIT_VAR(class_name); phalcon_get_class(class_name, this_ptr, 0 TSRMLS_CC); PHALCON_INIT_VAR(suffix); ZVAL_STRING(suffix, "Validator", 1); PHALCON_INIT_VAR(empty_string); ZVAL_STRING(empty_string, "", 1); PHALCON_INIT_NVAR(type); phalcon_fast_str_replace(type, suffix, empty_string, class_name TSRMLS_CC); } PHALCON_INIT_VAR(model_message); object_init_ex(model_message, phalcon_mvc_model_message_ce); phalcon_call_method_p3_noret(model_message, "__construct", message, field, type); phalcon_update_property_array_append(this_ptr, SL("_messages"), model_message TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Magic __set_state helps to re-build messages variable exporting * * @param array $message * @return Phalcon\Mvc\Model\Message */ PHP_METHOD(Phalcon_Mvc_Model_Message, __set_state){ zval *message, *message_text, *field, *type, *message_object; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &message); PHALCON_OBS_VAR(message_text); phalcon_array_fetch_string(&message_text, message, SL("_message"), PH_NOISY_CC); PHALCON_OBS_VAR(field); phalcon_array_fetch_string(&field, message, SL("_field"), PH_NOISY_CC); PHALCON_OBS_VAR(type); phalcon_array_fetch_string(&type, message, SL("_type"), PH_NOISY_CC); PHALCON_INIT_VAR(message_object); object_init_ex(message_object, phalcon_mvc_model_message_ce); phalcon_call_method_p3_noret(message_object, "__construct", message_text, field, type); RETURN_CTOR(message_object); }
/** * Restore the internal state of a service * * @param array $attributes * @return Phalcon\DI\Service */ PHP_METHOD(Phalcon_DI_Service, __set_state){ zval *attributes, *name, *definition, *shared; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &attributes); if (phalcon_array_isset_string(attributes, SS("_name"))) { PHALCON_OBS_VAR(name); phalcon_array_fetch_string(&name, attributes, SL("_name"), PH_NOISY); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_di_exception_ce, "The attribute '_name' is required"); return; } if (phalcon_array_isset_string(attributes, SS("_definition"))) { PHALCON_OBS_VAR(definition); phalcon_array_fetch_string(&definition, attributes, SL("_definition"), PH_NOISY); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_di_exception_ce, "The attribute '_name' is required"); return; } if (phalcon_array_isset_string(attributes, SS("_shared"))) { PHALCON_OBS_VAR(shared); phalcon_array_fetch_string(&shared, attributes, SL("_shared"), PH_NOISY); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_di_exception_ce, "The attribute '_shared' is required"); return; } object_init_ex(return_value, phalcon_di_service_ce); phalcon_call_method_p3_noret(return_value, "__construct", name, definition, shared); RETURN_MM(); }
/** * Registers an "always shared" service in the services container * * @param string $name * @param mixed $definition * @return Phalcon\DI\ServiceInterface */ PHP_METHOD(Phalcon_DI, setShared){ zval *name, *definition, *shared, *service; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &name, &definition); if (Z_TYPE_P(name) != IS_STRING) { PHALCON_THROW_EXCEPTION_STR(phalcon_di_exception_ce, "The service name must be a string"); return; } PHALCON_INIT_VAR(shared); ZVAL_BOOL(shared, 1); PHALCON_INIT_VAR(service); object_init_ex(service, phalcon_di_service_ce); phalcon_call_method_p3_noret(service, "__construct", name, definition, shared); phalcon_update_property_array(this_ptr, SL("_services"), name, service TSRMLS_CC); RETURN_CTOR(service); }
/** * Validate a set of data according to a set of rules * * @param array|object $data * @param object $entity * @return Phalcon\Validation\Message\Group */ PHP_METHOD(Phalcon_Validation, validate){ zval *data = NULL, *entity = NULL, *validators, *messages = NULL, *status = NULL; zval *cancel_on_fail, *scope = NULL, *attribute = NULL, *validator = NULL; zval *must_cancel = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 2, &data, &entity); if (!data) { PHALCON_INIT_VAR(data); } if (!entity) { PHALCON_INIT_VAR(entity); } PHALCON_OBS_VAR(validators); phalcon_read_property_this(&validators, this_ptr, SL("_validators"), PH_NOISY_CC); if (Z_TYPE_P(validators) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "There are no validators to validate"); return; } /** * Clear pre-calculated values */ phalcon_update_property_null(this_ptr, SL("_values") TSRMLS_CC); /** * Implicitly creates a Phalcon\Validation\Message\Group object */ PHALCON_INIT_VAR(messages); object_init_ex(messages, phalcon_validation_message_group_ce); phalcon_call_method_noret(messages, "__construct"); /** * Validation classes can implement the 'beforeValidation' callback */ if (phalcon_method_exists_ex(this_ptr, SS("beforevalidation") TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(status); phalcon_call_method_p3(status, this_ptr, "beforevalidation", data, entity, messages); if (PHALCON_IS_FALSE(status)) { RETURN_CCTOR(status); } } phalcon_update_property_this(this_ptr, SL("_messages"), messages TSRMLS_CC); if (Z_TYPE_P(data) == IS_ARRAY) { phalcon_update_property_this(this_ptr, SL("_data"), data TSRMLS_CC); } else { if (Z_TYPE_P(data) == IS_OBJECT) { phalcon_update_property_this(this_ptr, SL("_data"), data TSRMLS_CC); } } PHALCON_INIT_VAR(cancel_on_fail); ZVAL_STRING(cancel_on_fail, "cancelOnFail", 1); phalcon_is_iterable(validators, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(scope); if (Z_TYPE_P(scope) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "The validator scope is not valid"); return; } PHALCON_OBS_NVAR(attribute); phalcon_array_fetch_long(&attribute, scope, 0, PH_NOISY_CC); PHALCON_OBS_NVAR(validator); phalcon_array_fetch_long(&validator, scope, 1, PH_NOISY_CC); if (Z_TYPE_P(validator) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "One of the validators is not valid"); return; } PHALCON_INIT_NVAR(status); phalcon_call_method_p2(status, validator, "validate", this_ptr, attribute); /** * Check if the validation must be canceled if this validator fails */ if (PHALCON_IS_FALSE(status)) { PHALCON_INIT_NVAR(must_cancel); phalcon_call_method_p1(must_cancel, validator, "getoption", cancel_on_fail); if (zend_is_true(must_cancel)) { break; } } zend_hash_move_forward_ex(ah0, &hp0); } /** * Get the messages generated by the validators */ PHALCON_OBS_NVAR(messages); phalcon_read_property_this(&messages, this_ptr, SL("_messages"), PH_NOISY_CC); if (phalcon_method_exists_ex(this_ptr, SS("aftervalidation") TSRMLS_CC) == SUCCESS) { phalcon_call_method_p3_noret(this_ptr, "aftervalidation", data, entity, messages); } RETURN_CCTOR(messages); }
/** * 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); }
/** * Executes the validator * * @param Phalcon\Mvc\ModelInterface $record * @return boolean */ PHP_METHOD(Phalcon_Mvc_Model_Validator_Exclusionin, validate){ zval *record, *option = NULL, *field_name, *is_set, *domain; zval *value, *message = NULL, *joined_domain, *type; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &record); PHALCON_INIT_VAR(option); ZVAL_STRING(option, "field", 1); PHALCON_INIT_VAR(field_name); phalcon_call_method_p1(field_name, this_ptr, "getoption", option); if (Z_TYPE_P(field_name) != IS_STRING) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Field name must be a string"); return; } /** * The 'domain' option must be a valid array of not allowed values */ PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "domain", 1); PHALCON_INIT_VAR(is_set); phalcon_call_method_p1(is_set, this_ptr, "issetoption", option); if (PHALCON_IS_FALSE(is_set)) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "The option 'domain' is required for this validator"); return; } PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "domain", 1); PHALCON_INIT_VAR(domain); phalcon_call_method_p1(domain, this_ptr, "getoption", option); if (Z_TYPE_P(domain) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Option 'domain' must be an array"); return; } PHALCON_INIT_VAR(value); phalcon_call_method_p1(value, record, "readattribute", field_name); /** * We check if the value contained in the array using "in_array" from the PHP * userland */ if (phalcon_fast_in_array(value, domain TSRMLS_CC)) { /** * Check if the developer has defined a custom message */ PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "message", 1); PHALCON_INIT_VAR(message); phalcon_call_method_p1(message, this_ptr, "getoption", option); if (!zend_is_true(message)) { PHALCON_INIT_VAR(joined_domain); phalcon_fast_join_str(joined_domain, SL(", "), domain TSRMLS_CC); PHALCON_INIT_NVAR(message); PHALCON_CONCAT_SVSV(message, "Value of field '", field_name, "' must not be part of list: ", joined_domain); } PHALCON_INIT_VAR(type); ZVAL_STRING(type, "Exclusion", 1); phalcon_call_method_p3_noret(this_ptr, "appendmessage", message, field_name, type); RETURN_MM_FALSE; } RETURN_MM_TRUE; }
/** * Sends SQL statements to the database server returning the success state. * Use this method only when the SQL statement sent to the server is returning rows * *<code> * //Querying data * $resultset = $connection->query("SELECT * FROM robots WHERE type='mechanical'"); * $resultset = $connection->query("SELECT * FROM robots WHERE type=?", array("mechanical")); *</code> * * @param string $sqlStatement * @param array $bindParams * @param array $bindTypes * @return Phalcon\Db\ResultInterface */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, query){ zval *sql_statement, *bind_params = NULL, *bind_types = NULL; zval *events_manager, *event_name = NULL, *status, *pdo; zval *statement = NULL, *new_statement; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 2, &sql_statement, &bind_params, &bind_types); if (!bind_params) { PHALCON_INIT_VAR(bind_params); } if (!bind_types) { PHALCON_INIT_VAR(bind_types); } PHALCON_OBS_VAR(events_manager); phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); /** * Execute the beforeQuery event if a EventsManager is available */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_VAR(event_name); ZVAL_STRING(event_name, "db:beforeQuery", 1); phalcon_update_property_this(this_ptr, SL("_sqlStatement"), sql_statement TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_sqlVariables"), bind_params TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_sqlBindTypes"), bind_types TSRMLS_CC); PHALCON_INIT_VAR(status); phalcon_call_method_p3(status, events_manager, "fire", event_name, this_ptr, bind_params); if (PHALCON_IS_FALSE(status)) { RETURN_MM_FALSE; } } PHALCON_OBS_VAR(pdo); phalcon_read_property_this(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC); if (Z_TYPE_P(bind_params) == IS_ARRAY) { PHALCON_INIT_VAR(statement); phalcon_call_method_p1(statement, pdo, "prepare", sql_statement); if (Z_TYPE_P(statement) == IS_OBJECT) { PHALCON_INIT_VAR(new_statement); phalcon_call_method_p3(new_statement, this_ptr, "executeprepared", statement, bind_params, bind_types); PHALCON_CPY_WRT(statement, new_statement); } } else { PHALCON_INIT_NVAR(statement); phalcon_call_method_p1(statement, pdo, "query", sql_statement); } /** * Execute the afterQuery event if a EventsManager is available */ if (likely(Z_TYPE_P(statement) == IS_OBJECT)) { if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "db:afterQuery", 1); phalcon_call_method_p3_noret(events_manager, "fire", event_name, this_ptr, bind_params); } object_init_ex(return_value, phalcon_db_result_pdo_ce); phalcon_call_method_p5_noret(return_value, "__construct", this_ptr, statement, sql_statement, bind_params, bind_types); RETURN_MM(); } RETURN_CCTOR(statement); }
/** * Check whether a role is allowed to access an action from a resource * * <code> * //Does andres have access to the customers resource to create? * $acl->isAllowed('andres', 'Products', 'create'); * * //Do guests have access to any resource to edit? * $acl->isAllowed('guests', '*', 'edit'); * </code> * * @param string $role * @param string $resource * @param string $access * @return boolean */ PHP_METHOD(Phalcon_Acl_Adapter_Memory, isAllowed){ zval *role, *resource, *access, *events_manager; zval *event_name = NULL, *status, *default_access, *roles_names; zval *have_access = NULL, *access_list, *access_key = NULL; zval *role_inherits, *inherited_roles = NULL, *inherited_role = NULL; HashTable *ah0, *ah1, *ah2; HashPosition hp0, hp1, hp2; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 3, 0, &role, &resource, &access); phalcon_update_property_this(this_ptr, SL("_activeRole"), role TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_activeResource"), resource TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_activeAccess"), access TSRMLS_CC); PHALCON_OBS_VAR(events_manager); phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_VAR(event_name); ZVAL_STRING(event_name, "acl:beforeCheckAccess", 1); PHALCON_INIT_VAR(status); phalcon_call_method_p2(status, events_manager, "fire", event_name, this_ptr); if (PHALCON_IS_FALSE(status)) { RETURN_CCTOR(status); } } PHALCON_OBS_VAR(default_access); phalcon_read_property_this(&default_access, this_ptr, SL("_defaultAccess"), PH_NOISY_CC); /** * Check if the role exists */ PHALCON_OBS_VAR(roles_names); phalcon_read_property_this(&roles_names, this_ptr, SL("_rolesNames"), PH_NOISY_CC); if (!phalcon_array_isset(roles_names, role)) { RETURN_CCTOR(default_access); } PHALCON_INIT_VAR(have_access); PHALCON_OBS_VAR(access_list); phalcon_read_property_this(&access_list, this_ptr, SL("_access"), PH_NOISY_CC); PHALCON_INIT_VAR(access_key); PHALCON_CONCAT_VSVSV(access_key, role, "!", resource, "!", access); /** * Check if there is a direct combination for role-resource-access */ if (phalcon_array_isset(access_list, access_key)) { PHALCON_OBS_NVAR(have_access); phalcon_array_fetch(&have_access, access_list, access_key, PH_NOISY); } /** * Check in the inherits roles */ if (Z_TYPE_P(have_access) == IS_NULL) { PHALCON_OBS_VAR(role_inherits); phalcon_read_property_this(&role_inherits, this_ptr, SL("_roleInherits"), PH_NOISY_CC); if (phalcon_array_isset(role_inherits, role)) { PHALCON_OBS_VAR(inherited_roles); phalcon_array_fetch(&inherited_roles, role_inherits, role, PH_NOISY); } else { PHALCON_INIT_NVAR(inherited_roles); } if (Z_TYPE_P(inherited_roles) == IS_ARRAY) { phalcon_is_iterable(inherited_roles, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(inherited_role); PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VSVSV(access_key, inherited_role, "!", resource, "!", access); /** * Check if there is a direct combination in one of the inherited roles */ if (phalcon_array_isset(access_list, access_key)) { PHALCON_OBS_NVAR(have_access); phalcon_array_fetch(&have_access, access_list, access_key, PH_NOISY); break; } zend_hash_move_forward_ex(ah0, &hp0); } } } /** * If access wasn't found yet, try role-resource-* */ if (Z_TYPE_P(have_access) == IS_NULL) { PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VSVS(access_key, role, "!", resource, "!*"); /** * In the direct role */ if (phalcon_array_isset(access_list, access_key)) { PHALCON_OBS_NVAR(have_access); phalcon_array_fetch(&have_access, access_list, access_key, PH_NOISY); } else { if (Z_TYPE_P(inherited_roles) == IS_ARRAY) { phalcon_is_iterable(inherited_roles, &ah1, &hp1, 0, 0); while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_HVALUE(inherited_role); PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VSVS(access_key, inherited_role, "!", resource, "!*"); /** * In the inherited roles */ if (phalcon_array_isset(access_list, access_key)) { PHALCON_OBS_NVAR(have_access); phalcon_array_fetch(&have_access, access_list, access_key, PH_NOISY); break; } zend_hash_move_forward_ex(ah1, &hp1); } } } } /** * If access wasn't found yet, try role-*-* */ if (Z_TYPE_P(have_access) == IS_NULL) { PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VS(access_key, role, "!*!*"); /** * Try in the direct role */ if (phalcon_array_isset(access_list, access_key)) { PHALCON_OBS_NVAR(have_access); phalcon_array_fetch(&have_access, access_list, access_key, PH_NOISY); } else { if (Z_TYPE_P(inherited_roles) == IS_ARRAY) { phalcon_is_iterable(inherited_roles, &ah2, &hp2, 0, 0); while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) { PHALCON_GET_HVALUE(inherited_role); PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VS(access_key, inherited_role, "!*!*"); if (phalcon_array_isset(access_list, access_key)) { PHALCON_OBS_NVAR(have_access); phalcon_array_fetch(&have_access, access_list, access_key, PH_NOISY); break; } zend_hash_move_forward_ex(ah2, &hp2); } } } } phalcon_update_property_this(this_ptr, SL("_accessGranted"), have_access TSRMLS_CC); if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "acl:afterCheckAccess", 1); phalcon_call_method_p3_noret(events_manager, "fire", event_name, this_ptr, have_access); } if (Z_TYPE_P(have_access) == IS_NULL) { PHALCON_MM_RESTORE(); RETURN_LONG(0); } RETURN_CCTOR(have_access); }
/** * Executes the validator * * @param Phalcon\Mvc\ModelInterface $record * @return boolean */ PHP_METHOD(Phalcon_Mvc_Model_Validator_Uniqueness, validate){ zval *record, *option = NULL, *field, *dependency_injector; zval *service, *meta_data, *bind_types, *bind_data_types; zval *column_map = NULL, *conditions, *bind_params; zval *number = NULL, *compose_field = NULL, *column_field = NULL; zval *exception_message = NULL, *value = NULL, *compose_condition = NULL; zval *bind_type = NULL, *condition = NULL, *operation_made; zval *primary_fields, *primary_field = NULL, *attribute_field = NULL; zval *join_conditions, *params, *class_name; zval *message = NULL, *join_fields, *type; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &record); PHALCON_INIT_VAR(option); ZVAL_STRING(option, "field", 1); PHALCON_INIT_VAR(field); phalcon_call_method_p1(field, this_ptr, "getoption", option); PHALCON_INIT_VAR(dependency_injector); phalcon_call_method(dependency_injector, record, "getdi"); PHALCON_INIT_VAR(service); ZVAL_STRING(service, "modelsMetadata", 1); PHALCON_INIT_VAR(meta_data); phalcon_call_method_p1(meta_data, dependency_injector, "getshared", service); /** * PostgreSQL check if the compared constant has the same type as the column, so we * make cast to the data passed to match those column types */ PHALCON_INIT_VAR(bind_types); array_init(bind_types); PHALCON_INIT_VAR(bind_data_types); phalcon_call_method_p1(bind_data_types, meta_data, "getbindtypes", record); if (PHALCON_GLOBAL(orm).column_renaming) { PHALCON_INIT_VAR(column_map); phalcon_call_method_p1(column_map, meta_data, "getreversecolumnmap", record); } else { PHALCON_INIT_NVAR(column_map); } PHALCON_INIT_VAR(conditions); array_init(conditions); PHALCON_INIT_VAR(bind_params); array_init(bind_params); PHALCON_INIT_VAR(number); ZVAL_LONG(number, 0); if (Z_TYPE_P(field) == IS_ARRAY) { /** * The field can be an array of values */ phalcon_is_iterable(field, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(compose_field); /** * The reversed column map is used in the case to get real column name */ if (Z_TYPE_P(column_map) == IS_ARRAY) { if (phalcon_array_isset(column_map, compose_field)) { PHALCON_OBS_NVAR(column_field); phalcon_array_fetch(&column_field, column_map, compose_field, PH_NOISY); } else { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Column '", compose_field, "\" isn't part of the column map"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } } else { PHALCON_CPY_WRT(column_field, compose_field); } /** * Some database systems require that we pass the values using bind casting */ if (!phalcon_array_isset(bind_data_types, column_field)) { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Column '", column_field, "\" isn't part of the table columns"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } /** * The attribute could be "protected" so we read using "readattribute" */ PHALCON_INIT_NVAR(value); phalcon_call_method_p1(value, record, "readattribute", compose_field); PHALCON_INIT_NVAR(compose_condition); PHALCON_CONCAT_SVSV(compose_condition, "[", compose_field, "] = ?", number); phalcon_array_append(&conditions, compose_condition, PH_SEPARATE); phalcon_array_append(&bind_params, value, PH_SEPARATE); PHALCON_OBS_NVAR(bind_type); phalcon_array_fetch(&bind_type, bind_data_types, column_field, PH_NOISY); phalcon_array_append(&bind_types, bind_type, PH_SEPARATE); phalcon_increment(number); zend_hash_move_forward_ex(ah0, &hp0); } } else { /** * The reversed column map is used in the case to get real column name */ if (Z_TYPE_P(column_map) == IS_ARRAY) { if (phalcon_array_isset(column_map, field)) { PHALCON_OBS_NVAR(column_field); phalcon_array_fetch(&column_field, column_map, field, PH_NOISY); } else { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Column '", field, "\" isn't part of the column map"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } } else { PHALCON_CPY_WRT(column_field, field); } /** * Some database systems require that we pass the values using bind casting */ if (!phalcon_array_isset(bind_data_types, column_field)) { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Column '", column_field, "\" isn't part of the table columns"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } /** * We're checking the uniqueness with only one field */ PHALCON_INIT_NVAR(value); phalcon_call_method_p1(value, record, "readattribute", field); PHALCON_INIT_VAR(condition); PHALCON_CONCAT_SVS(condition, "[", field, "] = ?0"); phalcon_array_append(&conditions, condition, PH_SEPARATE); phalcon_array_append(&bind_params, value, PH_SEPARATE); PHALCON_OBS_NVAR(bind_type); phalcon_array_fetch(&bind_type, bind_data_types, column_field, PH_NOISY); phalcon_array_append(&bind_types, bind_type, PH_SEPARATE); phalcon_increment(number); } /** * If the operation is update, there must be values in the object */ PHALCON_INIT_VAR(operation_made); phalcon_call_method(operation_made, record, "getoperationmade"); if (PHALCON_IS_LONG(operation_made, 2)) { /** * We build a query with the primary key attributes */ if (PHALCON_GLOBAL(orm).column_renaming) { PHALCON_INIT_NVAR(column_map); phalcon_call_method_p1(column_map, meta_data, "getcolumnmap", record); } else { PHALCON_INIT_NVAR(column_map); } PHALCON_INIT_VAR(primary_fields); phalcon_call_method_p1(primary_fields, meta_data, "getprimarykeyattributes", record); phalcon_is_iterable(primary_fields, &ah1, &hp1, 0, 0); while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_HVALUE(primary_field); if (!phalcon_array_isset(bind_data_types, primary_field)) { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Column '", primary_field, "\" isn't part of the table columns"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } /** * Rename the column if there is a column map */ if (Z_TYPE_P(column_map) == IS_ARRAY) { if (phalcon_array_isset(column_map, primary_field)) { PHALCON_OBS_NVAR(attribute_field); phalcon_array_fetch(&attribute_field, column_map, primary_field, PH_NOISY); } else { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Column '", primary_field, "\" isn't part of the column map"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } } else { PHALCON_CPY_WRT(attribute_field, primary_field); } /** * Create a condition based on the renamed primary key */ PHALCON_INIT_NVAR(value); phalcon_call_method_p1(value, record, "readattribute", primary_field); PHALCON_INIT_NVAR(condition); PHALCON_CONCAT_SVSV(condition, "[", attribute_field, "] <> ?", number); phalcon_array_append(&conditions, condition, PH_SEPARATE); phalcon_array_append(&bind_params, value, PH_SEPARATE); PHALCON_OBS_NVAR(bind_type); phalcon_array_fetch(&bind_type, bind_data_types, primary_field, PH_NOISY); phalcon_array_append(&bind_types, bind_type, PH_SEPARATE); phalcon_increment(number); zend_hash_move_forward_ex(ah1, &hp1); } } PHALCON_INIT_VAR(join_conditions); phalcon_fast_join_str(join_conditions, SL(" AND "), conditions TSRMLS_CC); /** * We don't trust the user, so we pass the parameters as bound parameters */ PHALCON_INIT_VAR(params); array_init(params); phalcon_array_update_string(¶ms, SL("di"), &dependency_injector, PH_COPY | PH_SEPARATE); phalcon_array_update_string(¶ms, SL("conditions"), &join_conditions, PH_COPY | PH_SEPARATE); phalcon_array_update_string(¶ms, SL("bind"), &bind_params, PH_COPY | PH_SEPARATE); phalcon_array_update_string(¶ms, SL("bindTypes"), &bind_types, PH_COPY | PH_SEPARATE); PHALCON_INIT_VAR(class_name); phalcon_get_class(class_name, record, 0 TSRMLS_CC); /** * Check using a standard count */ phalcon_call_zval_str_static_p1(number, class_name, "count", params); if (!PHALCON_IS_LONG(number, 0)) { /** * Check if the developer has defined a custom message */ PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "message", 1); PHALCON_INIT_VAR(message); phalcon_call_method_p1(message, this_ptr, "getoption", option); if (!zend_is_true(message)) { if (Z_TYPE_P(field) == IS_ARRAY) { PHALCON_INIT_VAR(join_fields); phalcon_fast_join_str(join_fields, SL(", "), field TSRMLS_CC); PHALCON_INIT_NVAR(message); PHALCON_CONCAT_SVS(message, "Value of fields: '", join_fields, "' are already present in another record"); } else { PHALCON_INIT_NVAR(message); PHALCON_CONCAT_SVS(message, "Value of field: '", field, "' is already present in another record"); } } /** * Append the message to the validator */ PHALCON_INIT_VAR(type); ZVAL_STRING(type, "Unique", 1); phalcon_call_method_p3_noret(this_ptr, "appendmessage", message, field, type); RETURN_MM_FALSE; } RETURN_MM_TRUE; }
/** * 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, *must_clean, *views_dir; zval *views_dir_path, *engines, *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_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_INIT_VAR(status); phalcon_call_method_p2(status, events_manager, "fire", event_name, this_ptr); if (PHALCON_IS_FALSE(status)) { RETURN_MM_NULL(); } } PHALCON_INIT_VAR(not_exists); ZVAL_BOOL(not_exists, 1); PHALCON_INIT_VAR(must_clean); ZVAL_BOOL(must_clean, 1); PHALCON_OBS_VAR(views_dir); phalcon_read_property_this(&views_dir, this_ptr, SL("_viewsDir"), PH_NOISY_CC); PHALCON_INIT_VAR(views_dir_path); PHALCON_CONCAT_VV(views_dir_path, views_dir, path); /** * Load the template engines */ PHALCON_INIT_VAR(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_INIT_NVAR(status); phalcon_call_method_p3(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_p3_noret(engine, "render", view_engine_path, 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_p2_noret(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_p2_noret(events_manager, "fire", event_name, this_ptr); } PHALCON_MM_RESTORE(); }
/** * 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, *dependency_injector, *events_manager; zval *service = NULL, *router, *module_name, *event_name = NULL; zval *status = NULL, *modules, *exception_msg = NULL, *module; zval *path, *class_name = NULL, *module_object, *task_name; zval *action_name, *params, *dispatcher, *task; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, &arguments); if (!arguments) { PHALCON_INIT_VAR(arguments); array_init(arguments); } 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_cli_console_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); PHALCON_INIT_VAR(service); ZVAL_STRING(service, "router", 1); PHALCON_INIT_VAR(router); phalcon_call_method_p1(router, dependency_injector, "getshared", service); phalcon_call_method_p1_noret(router, "handle", arguments); PHALCON_INIT_VAR(module_name); phalcon_call_method(module_name, router, "getmodulename"); if (zend_is_true(module_name)) { if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_VAR(event_name); ZVAL_STRING(event_name, "console:beforeStartModule", 1); PHALCON_INIT_VAR(status); phalcon_call_method_p3(status, events_manager, "fire", event_name, this_ptr, module_name); if (PHALCON_IS_FALSE(status)) { RETURN_MM_FALSE; } } 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 console container"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_cli_console_exception_ce, exception_msg); return; } PHALCON_OBS_VAR(module); phalcon_array_fetch(&module, modules, module_name, PH_NOISY); if (Z_TYPE_P(module) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_cli_console_exception_ce, "Invalid module definition path"); return; } if (phalcon_array_isset_string(module, SS("path"))) { PHALCON_OBS_VAR(path); phalcon_array_fetch_string(&path, module, SL("path"), PH_NOISY); 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_cli_console_exception_ce, exception_msg); return; } } 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); } PHALCON_INIT_VAR(module_object); phalcon_call_method_p1(module_object, dependency_injector, "get", class_name); phalcon_call_method_noret(module_object, "registerautoloaders"); phalcon_call_method_p1_noret(module_object, "registerservices", dependency_injector); 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, "console: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; } } } PHALCON_INIT_VAR(task_name); phalcon_call_method(task_name, router, "gettaskname"); 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); PHALCON_VERIFY_INTERFACE(dispatcher, phalcon_dispatcherinterface_ce); phalcon_call_method_p1_noret(dispatcher, "settaskname", task_name); phalcon_call_method_p1_noret(dispatcher, "setactionname", action_name); phalcon_call_method_p1_noret(dispatcher, "setparams", params); if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "console:beforeHandleTask", 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; } } PHALCON_INIT_VAR(task); phalcon_call_method(task, dispatcher, "dispatch"); if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "console:afterHandleTask", 1); phalcon_call_method_p3_noret(events_manager, "fire", event_name, this_ptr, task); } RETURN_CCTOR(task); }
/** * Create/Returns a new transaction or an existing one * * @param boolean $autoBegin * @return Phalcon\Mvc\Model\TransactionInterface */ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, getOrCreateTransaction){ zval *auto_begin = NULL, *dependency_injector, *number; zval *transactions, *transaction = NULL, *false_value = NULL; zval *service; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, &auto_begin); if (!auto_begin) { PHALCON_INIT_VAR(auto_begin); ZVAL_BOOL(auto_begin, 1); } 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_model_transaction_exception_ce, "A dependency injector container is required to obtain the services related to the ORM"); return; } PHALCON_OBS_VAR(number); phalcon_read_property_this(&number, this_ptr, SL("_number"), PH_NOISY_CC); if (zend_is_true(number)) { PHALCON_OBS_VAR(transactions); phalcon_read_property_this(&transactions, this_ptr, SL("_transactions"), PH_NOISY_CC); if (Z_TYPE_P(transactions) == IS_ARRAY) { phalcon_is_iterable(transactions, &ah0, &hp0, 0, 1); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(transaction); if (Z_TYPE_P(transaction) == IS_OBJECT) { PHALCON_INIT_NVAR(false_value); ZVAL_BOOL(false_value, 0); phalcon_call_method_p1_noret(transaction, "setisnewtransaction", false_value); RETURN_CCTOR(transaction); } zend_hash_move_backwards_ex(ah0, &hp0); } } } PHALCON_OBS_VAR(service); phalcon_read_property_this(&service, this_ptr, SL("_service"), PH_NOISY_CC); PHALCON_INIT_VAR(transaction); object_init_ex(transaction, phalcon_mvc_model_transaction_ce); phalcon_call_method_p3_noret(transaction, "__construct", dependency_injector, auto_begin, service); phalcon_call_method_p1_noret(transaction, "settransactionmanager", this_ptr); phalcon_update_property_array_append(this_ptr, SL("_transactions"), transaction TSRMLS_CC); phalcon_property_incr(this_ptr, SL("_number") TSRMLS_CC); RETURN_CTOR(transaction); }
/** * Commits the active transaction in the connection * * @param boolean $nesting * @return boolean */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, commit){ zval *nesting = NULL, *pdo, *transaction_level, *events_manager = NULL; zval *event_name = NULL, *ntw_savepoint, *savepoint_name; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, &nesting); if (!nesting) { PHALCON_INIT_VAR(nesting); ZVAL_BOOL(nesting, 1); } PHALCON_OBS_VAR(pdo); phalcon_read_property_this(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC); if (Z_TYPE_P(pdo) != IS_OBJECT) { RETURN_MM_FALSE; } /** * Check the transaction nesting level */ PHALCON_OBS_VAR(transaction_level); phalcon_read_property_this(&transaction_level, this_ptr, SL("_transactionLevel"), PH_NOISY_CC); if (!zend_is_true(transaction_level)) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "There is no active transaction"); return; } if (PHALCON_IS_LONG(transaction_level, 1)) { PHALCON_OBS_VAR(events_manager); phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); /** * Notify the events manager about the commited transaction */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_VAR(event_name); ZVAL_STRING(event_name, "db:commitTransaction", 1); phalcon_call_method_p2_noret(events_manager, "fire", event_name, this_ptr); } /** * Reduce the transaction nesting level */ phalcon_property_decr(this_ptr, SL("_transactionLevel") TSRMLS_CC); phalcon_call_method(return_value, pdo, "commit"); RETURN_MM(); } else { if (zend_is_true(transaction_level)) { if (zend_is_true(nesting)) { /** * Check if the current database system supports nested transactions */ PHALCON_INIT_VAR(ntw_savepoint); phalcon_call_method(ntw_savepoint, this_ptr, "isnestedtransactionswithsavepoints"); if (zend_is_true(ntw_savepoint)) { PHALCON_OBS_NVAR(events_manager); phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); PHALCON_INIT_VAR(savepoint_name); phalcon_call_method(savepoint_name, this_ptr, "getnestedtransactionsavepointname"); /** * Notify the events manager about the commited savepoint */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "db:releaseSavepoint", 1); phalcon_call_method_p3_noret(events_manager, "fire", event_name, this_ptr, savepoint_name); } /** * Reduce the transaction nesting level */ phalcon_property_decr(this_ptr, SL("_transactionLevel") TSRMLS_CC); phalcon_call_method_p1(return_value, this_ptr, "releasesavepoint", savepoint_name); RETURN_MM(); } } } } /** * Reduce the transaction nesting level */ if (PHALCON_GT_LONG(transaction_level, 0)) { phalcon_property_decr(this_ptr, SL("_transactionLevel") TSRMLS_CC); } RETURN_MM_FALSE; }
/** * Starts a transaction in the connection * * @param boolean $nesting * @return boolean */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, begin){ zval *nesting = NULL, *pdo, *transaction_level, *events_manager = NULL; zval *event_name = NULL, *ntw_savepoint, *savepoint_name; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, &nesting); if (!nesting) { PHALCON_INIT_VAR(nesting); ZVAL_BOOL(nesting, 1); } PHALCON_OBS_VAR(pdo); phalcon_read_property_this(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC); if (Z_TYPE_P(pdo) != IS_OBJECT) { RETURN_MM_FALSE; } /** * Increase the transaction nesting level */ phalcon_property_incr(this_ptr, SL("_transactionLevel") TSRMLS_CC); /** * Check the transaction nesting level */ PHALCON_OBS_VAR(transaction_level); phalcon_read_property_this(&transaction_level, this_ptr, SL("_transactionLevel"), PH_NOISY_CC); if (PHALCON_IS_LONG(transaction_level, 1)) { PHALCON_OBS_VAR(events_manager); phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); /** * Notify the events manager about the started transaction */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_VAR(event_name); ZVAL_STRING(event_name, "db:beginTransaction", 1); phalcon_call_method_p2_noret(events_manager, "fire", event_name, this_ptr); } phalcon_call_method(return_value, pdo, "begintransaction"); RETURN_MM(); } else { if (zend_is_true(transaction_level)) { if (zend_is_true(nesting)) { PHALCON_INIT_VAR(ntw_savepoint); phalcon_call_method(ntw_savepoint, this_ptr, "isnestedtransactionswithsavepoints"); if (zend_is_true(ntw_savepoint)) { PHALCON_OBS_NVAR(events_manager); phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); PHALCON_INIT_VAR(savepoint_name); phalcon_call_method(savepoint_name, this_ptr, "getnestedtransactionsavepointname"); /** * Notify the events manager about the created savepoint */ if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "db:createSavepoint", 1); phalcon_call_method_p3_noret(events_manager, "fire", event_name, this_ptr, savepoint_name); } phalcon_call_method_p1(return_value, this_ptr, "createsavepoint", savepoint_name); RETURN_MM(); } } } } RETURN_MM_FALSE; }
/** * Sends SQL statements to the database server returning the success state. * Use this method only when the SQL statement sent to the server doesn't return any row * *<code> * //Inserting data * $success = $connection->execute("INSERT INTO robots VALUES (1, 'Astro Boy')"); * $success = $connection->execute("INSERT INTO robots VALUES (?, ?)", array(1, 'Astro Boy')); *</code> * * @param string $sqlStatement * @param array $bindParams * @param array $bindTypes * @return boolean */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, execute){ zval *sql_statement, *bind_params = NULL, *bind_types = NULL; zval *events_manager, *event_name = NULL, *status, *affected_rows = NULL; zval *pdo, *statement, *new_statement; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 2, &sql_statement, &bind_params, &bind_types); if (!bind_params) { PHALCON_INIT_VAR(bind_params); } if (!bind_types) { PHALCON_INIT_VAR(bind_types); } /** * Execute the beforeQuery event if a EventsManager is available */ PHALCON_OBS_VAR(events_manager); phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_VAR(event_name); ZVAL_STRING(event_name, "db:beforeQuery", 1); phalcon_update_property_this(this_ptr, SL("_sqlStatement"), sql_statement TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_sqlVariables"), bind_params TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_sqlBindTypes"), bind_types TSRMLS_CC); PHALCON_INIT_VAR(status); phalcon_call_method_p3(status, events_manager, "fire", event_name, this_ptr, bind_params); if (PHALCON_IS_FALSE(status)) { RETURN_MM_FALSE; } } /** * Initialize affected_rows to 0 */ PHALCON_INIT_VAR(affected_rows); ZVAL_LONG(affected_rows, 0); PHALCON_OBS_VAR(pdo); phalcon_read_property_this(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC); if (Z_TYPE_P(bind_params) == IS_ARRAY) { PHALCON_INIT_VAR(statement); phalcon_call_method_p1(statement, pdo, "prepare", sql_statement); if (Z_TYPE_P(statement) == IS_OBJECT) { PHALCON_INIT_VAR(new_statement); phalcon_call_method_p3(new_statement, this_ptr, "executeprepared", statement, bind_params, bind_types); phalcon_call_method(affected_rows, new_statement, "rowcount"); } } else { PHALCON_INIT_NVAR(affected_rows); phalcon_call_method_p1(affected_rows, pdo, "exec", sql_statement); } /** * Execute the afterQuery event if a EventsManager is available */ if (Z_TYPE_P(affected_rows) == IS_LONG) { phalcon_update_property_this(this_ptr, SL("_affectedRows"), affected_rows TSRMLS_CC); if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "db:afterQuery", 1); phalcon_call_method_p3_noret(events_manager, "fire", event_name, this_ptr, bind_params); } } RETURN_MM_TRUE; }
/** * Phalcon\DI\FactoryDefault constructor */ PHP_METHOD(Phalcon_DI_FactoryDefault, __construct){ zval *shared, *name = NULL, *definition = NULL, *router, *dispatcher; zval *url, *models_manager, *models_metadata; zval *response, *cookies, *request, *filter, *escaper; zval *annotations, *security, *crypt, *flash, *flash_session; zval *tag, *session, *session_bag, *events_manager; zval *transaction_manager, *assets, *services; PHALCON_MM_GROW(); PHALCON_CALL_PARENT_NORETURN(this_ptr, "Phalcon\\DI\\FactoryDefault", "__construct"); PHALCON_INIT_VAR(shared); ZVAL_BOOL(shared, 1); PHALCON_INIT_VAR(name); ZVAL_STRING(name, "router", 1); PHALCON_INIT_VAR(definition); ZVAL_STRING(definition, "Phalcon\\Mvc\\Router", 1); PHALCON_INIT_VAR(router); object_init_ex(router, phalcon_di_service_ce); phalcon_call_method_p3_noret(router, "__construct", name, definition, shared); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "dispatcher", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Mvc\\Dispatcher", 1); PHALCON_INIT_VAR(dispatcher); object_init_ex(dispatcher, phalcon_di_service_ce); phalcon_call_method_p3_noret(dispatcher, "__construct", name, definition, shared); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "url", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Mvc\\Url", 1); PHALCON_INIT_VAR(url); object_init_ex(url, phalcon_di_service_ce); phalcon_call_method_p3_noret(url, "__construct", name, definition, shared); /** * Models manager for ORM */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "modelsManager", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Mvc\\Model\\Manager", 1); PHALCON_INIT_VAR(models_manager); object_init_ex(models_manager, phalcon_di_service_ce); phalcon_call_method_p3_noret(models_manager, "__construct", name, definition, shared); /** * Models meta-data using the Memory adapter */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "modelsMetadata", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Mvc\\Model\\MetaData\\Memory", 1); PHALCON_INIT_VAR(models_metadata); object_init_ex(models_metadata, phalcon_di_service_ce); phalcon_call_method_p3_noret(models_metadata, "__construct", name, definition, shared); /** * Request/Response are always shared */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "response", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Http\\Response", 1); PHALCON_INIT_VAR(response); object_init_ex(response, phalcon_di_service_ce); phalcon_call_method_p3_noret(response, "__construct", name, definition, shared); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "cookies", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Http\\Response\\Cookies", 1); PHALCON_INIT_VAR(cookies); object_init_ex(cookies, phalcon_di_service_ce); phalcon_call_method_p3_noret(cookies, "__construct", name, definition, shared); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "request", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Http\\Request", 1); PHALCON_INIT_VAR(request); object_init_ex(request, phalcon_di_service_ce); phalcon_call_method_p3_noret(request, "__construct", name, definition, shared); /** * Filter/Escaper services are always shared */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "filter", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Filter", 1); PHALCON_INIT_VAR(filter); object_init_ex(filter, phalcon_di_service_ce); phalcon_call_method_p3_noret(filter, "__construct", name, definition, shared); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "escaper", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Escaper", 1); PHALCON_INIT_VAR(escaper); object_init_ex(escaper, phalcon_di_service_ce); phalcon_call_method_p3_noret(escaper, "__construct", name, definition, shared); /** * Default annotations service */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "annotations", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Annotations\\Adapter\\Memory", 1); PHALCON_INIT_VAR(annotations); object_init_ex(annotations, phalcon_di_service_ce); phalcon_call_method_p3_noret(annotations, "__construct", name, definition, shared); /** * Security doesn't need to be shared, but anyways we register it as shared */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "security", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Security", 1); PHALCON_INIT_VAR(security); object_init_ex(security, phalcon_di_service_ce); phalcon_call_method_p3_noret(security, "__construct", name, definition, shared); /** * Crypt Service */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "crypt", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Crypt", 1); PHALCON_INIT_VAR(crypt); object_init_ex(crypt, phalcon_di_service_ce); phalcon_call_method_p3_noret(crypt, "__construct", name, definition, shared); /** * Flash services are always shared */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "flash", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Flash\\Direct", 1); PHALCON_INIT_VAR(flash); object_init_ex(flash, phalcon_di_service_ce); phalcon_call_method_p3_noret(flash, "__construct", name, definition, shared); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "flashSession", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Flash\\Session", 1); PHALCON_INIT_VAR(flash_session); object_init_ex(flash_session, phalcon_di_service_ce); phalcon_call_method_p3_noret(flash_session, "__construct", name, definition, shared); /** * Tag/Helpers */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "tag", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Tag", 1); PHALCON_INIT_VAR(tag); object_init_ex(tag, phalcon_di_service_ce); phalcon_call_method_p3_noret(tag, "__construct", name, definition, shared); /** * Session is always shared */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "session", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Session\\Adapter\\Files", 1); PHALCON_INIT_VAR(session); object_init_ex(session, phalcon_di_service_ce); phalcon_call_method_p3_noret(session, "__construct", name, definition, shared); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "sessionBag", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Session\\Bag", 1); PHALCON_INIT_VAR(session_bag); object_init_ex(session_bag, phalcon_di_service_ce); phalcon_call_method_p2_noret(session_bag, "__construct", name, definition); /** * Events Manager is always shared */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "eventsManager", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Events\\Manager", 1); PHALCON_INIT_VAR(events_manager); object_init_ex(events_manager, phalcon_di_service_ce); phalcon_call_method_p3_noret(events_manager, "__construct", name, definition, shared); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "transactions", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Mvc\\Model\\Transaction\\Manager", 1); PHALCON_INIT_VAR(transaction_manager); object_init_ex(transaction_manager, phalcon_di_service_ce); phalcon_call_method_p3_noret(transaction_manager, "__construct", name, definition, shared); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "assets", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Assets\\Manager", 1); PHALCON_INIT_VAR(assets); object_init_ex(assets, phalcon_di_service_ce); phalcon_call_method_p3_noret(assets, "__construct", name, definition, shared); /** * Register services */ PHALCON_INIT_VAR(services); array_init_size(services, 21); phalcon_array_update_string(&services, SL("router"), &router, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("dispatcher"), &dispatcher, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("url"), &url, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("modelsManager"), &models_manager, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("modelsMetadata"), &models_metadata, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("response"), &response, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("cookies"), &cookies, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("request"), &request, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("filter"), &filter, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("escaper"), &escaper, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("security"), &security, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("crypt"), &crypt, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("annotations"), &annotations, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("flash"), &flash, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("flashSession"), &flash_session, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("tag"), &tag, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("session"), &session, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("sessionBag"), &session_bag, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("eventsManager"), &events_manager, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("transactionManager"), &transaction_manager, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("assets"), &assets, PH_COPY | PH_SEPARATE); /** * Update the internal services properties */ phalcon_update_property_this(this_ptr, SL("_services"), services TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Executes the validation * * @param Phalcon\Validation $validator * @param string $attribute * @return boolean */ PHP_METHOD(Phalcon_Validation_Validator_StringLength, validate){ zval *validator, *attribute, *option = NULL, *is_set_min; zval *is_set_max, *value, *length = NULL, *invalid_maximum = NULL; zval *invalid_minimum = NULL, *maximum, *message_str = NULL; zval *type = NULL, *message = NULL, *minimum; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &validator, &attribute); /** * At least one of 'min' or 'max' must be set */ PHALCON_INIT_VAR(option); ZVAL_STRING(option, "min", 1); PHALCON_INIT_VAR(is_set_min); phalcon_call_method_p1(is_set_min, this_ptr, "issetoption", option); PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "max", 1); PHALCON_INIT_VAR(is_set_max); phalcon_call_method_p1(is_set_max, this_ptr, "issetoption", option); if (!zend_is_true(is_set_min)) { if (!zend_is_true(is_set_max)) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "A minimum or maximum must be set"); return; } } PHALCON_INIT_VAR(value); phalcon_call_method_p1(value, validator, "getvalue", attribute); /** * Check if mbstring is available to calculate the correct length */ if (phalcon_function_exists_ex(SS("mb_strlen") TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(length); phalcon_call_func_p1(length, "mb_strlen", value); } else { PHALCON_INIT_NVAR(length); phalcon_fast_strlen(length, value); } PHALCON_INIT_VAR(invalid_maximum); ZVAL_BOOL(invalid_maximum, 0); PHALCON_INIT_VAR(invalid_minimum); ZVAL_BOOL(invalid_minimum, 0); /** * Maximum length */ if (zend_is_true(is_set_max)) { PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "max", 1); PHALCON_INIT_VAR(maximum); phalcon_call_method_p1(maximum, this_ptr, "getoption", option); is_smaller_function(invalid_maximum, maximum, length TSRMLS_CC); if (PHALCON_IS_TRUE(invalid_maximum)) { /** * Check if the developer has defined a custom message */ PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "messageMaximum", 1); PHALCON_INIT_VAR(message_str); phalcon_call_method_p1(message_str, this_ptr, "getoption", option); if (!zend_is_true(message_str)) { PHALCON_INIT_NVAR(message_str); PHALCON_CONCAT_SVSVS(message_str, "Value of field '", attribute, "' exceeds the maximum ", maximum, " characters"); } PHALCON_INIT_VAR(type); ZVAL_STRING(type, "TooLong", 1); PHALCON_INIT_VAR(message); object_init_ex(message, phalcon_validation_message_ce); phalcon_call_method_p3_noret(message, "__construct", message_str, attribute, type); phalcon_call_method_p1_noret(validator, "appendmessage", message); RETURN_MM_FALSE; } } /** * Minimum length */ if (zend_is_true(is_set_min)) { PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "min", 1); PHALCON_INIT_VAR(minimum); phalcon_call_method_p1(minimum, this_ptr, "getoption", option); is_smaller_function(invalid_minimum, length, minimum TSRMLS_CC); if (PHALCON_IS_TRUE(invalid_minimum)) { /** * Check if the developer has defined a custom message */ PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "messageMinimum", 1); PHALCON_INIT_NVAR(message_str); phalcon_call_method_p1(message_str, this_ptr, "getoption", option); if (!zend_is_true(message_str)) { PHALCON_INIT_NVAR(message_str); PHALCON_CONCAT_SVSVS(message_str, "Value of field '", attribute, "' is less than the minimum ", minimum, " characters"); } PHALCON_INIT_NVAR(type); ZVAL_STRING(type, "TooShort", 1); PHALCON_INIT_NVAR(message); object_init_ex(message, phalcon_validation_message_ce); phalcon_call_method_p3_noret(message, "__construct", message_str, attribute, type); phalcon_call_method_p1_noret(validator, "appendmessage", message); RETURN_MM_FALSE; } } RETURN_MM_TRUE; }
/** * Phalcon\DI\FactoryDefault\CLI constructor */ PHP_METHOD(Phalcon_DI_FactoryDefault_CLI, __construct){ zval *shared, *name = NULL, *definition = NULL, *router, *dispatcher; zval *models_manager, *models_metadata, *filter; zval *escaper, *annotations, *security, *events_manager; zval *transaction_manager, *services; PHALCON_MM_GROW(); PHALCON_CALL_PARENT_NORETURN(this_ptr, "Phalcon\\DI\\FactoryDefault\\CLI", "__construct"); PHALCON_INIT_VAR(shared); ZVAL_BOOL(shared, 1); PHALCON_INIT_VAR(name); ZVAL_STRING(name, "router", 1); PHALCON_INIT_VAR(definition); ZVAL_STRING(definition, "Phalcon\\CLI\\Router", 1); PHALCON_INIT_VAR(router); object_init_ex(router, phalcon_di_service_ce); phalcon_call_method_p2_noret(router, "__construct", name, definition); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "dispatcher", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\CLI\\Dispatcher", 1); PHALCON_INIT_VAR(dispatcher); object_init_ex(dispatcher, phalcon_di_service_ce); phalcon_call_method_p2_noret(dispatcher, "__construct", name, definition); /** * Models manager for ORM */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "modelsManager", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Mvc\\Model\\Manager", 1); PHALCON_INIT_VAR(models_manager); object_init_ex(models_manager, phalcon_di_service_ce); phalcon_call_method_p2_noret(models_manager, "__construct", name, definition); /** * Models meta-data using the Memory adapter */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "modelsMetadata", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Mvc\\Model\\Metadata\\Memory", 1); PHALCON_INIT_VAR(models_metadata); object_init_ex(models_metadata, phalcon_di_service_ce); phalcon_call_method_p2_noret(models_metadata, "__construct", name, definition); /** * Filter/Escaper services are always shared */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "filter", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Filter", 1); PHALCON_INIT_VAR(filter); object_init_ex(filter, phalcon_di_service_ce); phalcon_call_method_p3_noret(filter, "__construct", name, definition, shared); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "escaper", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Escaper", 1); PHALCON_INIT_VAR(escaper); object_init_ex(escaper, phalcon_di_service_ce); phalcon_call_method_p3_noret(escaper, "__construct", name, definition, shared); /** * Default annotations service */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "annotations", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Annotations\\Adapter\\Memory", 1); PHALCON_INIT_VAR(annotations); object_init_ex(annotations, phalcon_di_service_ce); phalcon_call_method_p3_noret(annotations, "__construct", name, definition, shared); /** * Security doesn't need to be shared, but anyways we register it as shared */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "security", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Security", 1); PHALCON_INIT_VAR(security); object_init_ex(security, phalcon_di_service_ce); phalcon_call_method_p3_noret(security, "__construct", name, definition, shared); /** * Events Manager is always shared */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "eventsManager", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Events\\Manager", 1); PHALCON_INIT_VAR(events_manager); object_init_ex(events_manager, phalcon_di_service_ce); phalcon_call_method_p3_noret(events_manager, "__construct", name, definition, shared); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Mvc\\Model\\Transaction\\Manager", 1); PHALCON_INIT_VAR(transaction_manager); object_init_ex(transaction_manager, phalcon_di_service_ce); phalcon_call_method_p2_noret(transaction_manager, "__construct", name, definition); PHALCON_INIT_VAR(services); array_init_size(services, 10); phalcon_array_update_string(&services, SL("router"), &router, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("dispatcher"), &dispatcher, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("modelsManager"), &models_manager, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("modelsMetadata"), &models_metadata, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("filter"), &filter, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("escaper"), &escaper, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("annotations"), &annotations, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("security"), &security, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("eventsManager"), &events_manager, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&services, SL("transactionManager"), &transaction_manager, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_services"), services TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Executes a prepared statement binding. This function uses integer indexes starting from zero * *<code> * $statement = $db->prepare('SELECT * FROM robots WHERE name = :name'); * $result = $connection->executePrepared($statement, array('name' => 'Voltron')); *</code> * * @param \PDOStatement $statement * @param array $placeholders * @param array $dataTypes * @return \PDOStatement */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, executePrepared){ zval *statement = NULL, *placeholders = NULL, *data_types = NULL; zval *one, *value = NULL, *wildcard = NULL, *parameter = NULL, *type = NULL, *cast_value = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &statement, &placeholders, &data_types) == FAILURE) { RETURN_MM_NULL(); } PHALCON_INIT_VAR(one); ZVAL_LONG(one, 1); if (!phalcon_is_iterable_ex(placeholders, &ah0, &hp0, 0, 0)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_KEY(wildcard, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); if (Z_TYPE_P(wildcard) == IS_LONG) { PHALCON_INIT_NVAR(parameter); phalcon_add_function(parameter, wildcard, one TSRMLS_CC); } else { if (Z_TYPE_P(wildcard) == IS_STRING) { PHALCON_CPY_WRT(parameter, wildcard); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter"); return; } } if (Z_TYPE_P(data_types) == IS_ARRAY) { if (likely(phalcon_array_isset(data_types, wildcard))) { /** * The bind type is double so we try to get the double value */ PHALCON_OBS_NVAR(type); phalcon_array_fetch(&type, data_types, wildcard, PH_NOISY); if (phalcon_compare_strict_long(type, 32 TSRMLS_CC)) { PHALCON_INIT_NVAR(cast_value); phalcon_cast(cast_value, value, IS_DOUBLE); PHALCON_INIT_NVAR(type); ZVAL_LONG(type, 1024); } else { PHALCON_CPY_WRT(cast_value, value); } /** * 1024 is ignore the bind type */ Z_SET_ISREF_P(cast_value); if (phalcon_compare_strict_long(type, 1024 TSRMLS_CC)) { phalcon_call_method_p2_noret(statement, "bindparam", parameter, cast_value); } else { phalcon_call_method_p3_noret(statement, "bindparam", parameter, cast_value, type); } Z_UNSET_ISREF_P(cast_value); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind type parameter"); return; } } else { Z_SET_ISREF_P(value); phalcon_call_method_p2_noret(statement, "bindparam", parameter, value); Z_UNSET_ISREF_P(value); } zend_hash_move_forward_ex(ah0, &hp0); } phalcon_call_method_noret(statement, "execute"); RETURN_CCTOR(statement); }