/**
* 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);
}
