/**
* Executes the validation
*
* @param Phalcon\Validation $validator
* @param string $attribute
* @return boolean
*/
PHP_METHOD(Phalcon_Validation_Validator_File, validate)
{
zval *validator, *attribute, value = {}, allow_empty = {}, mimes = {}, minsize = {}, maxsize = {}, minwidth = {}, maxwidth = {}, minheight = {}, maxheight = {};
zval valid = {}, type = {}, code = {}, message_str = {}, message = {}, join_mimes = {}, label = {}, pairs = {}, prepared = {};
zend_class_entry *ce = Z_OBJCE_P(getThis());
phalcon_fetch_params(0, 2, 0, &validator, &attribute);
PHALCON_VERIFY_CLASS_EX(validator, phalcon_validation_ce, phalcon_validation_exception_ce, 0);
PHALCON_CALL_METHODW(&value, validator, "getvalue", attribute);
RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&allow_empty, ce, getThis(), ISV(allowEmpty)));
if (zend_is_true(&allow_empty) && phalcon_validation_validator_isempty_helper(&value)) {
RETURN_TRUE;
}
RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&mimes, ce, getThis(), "mimes"));
RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&minsize, ce, getThis(), "minsize"));
RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&maxsize, ce, getThis(), "maxsize"));
RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&minwidth, ce, getThis(), "minwidth"));
RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&maxwidth, ce, getThis(), "maxwidth"));
RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&minheight, ce, getThis(), "minheight"));
RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&maxheight, ce, getThis(), "maxheight"));
PHALCON_CALL_SELFW(&valid, "valid", &value, &minsize, &maxsize, &mimes, &minwidth, &maxwidth, &minheight, &maxheight);
if (PHALCON_IS_FALSE(&valid)) {
phalcon_return_property(&type, getThis(), SL("_type"));
RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&label, ce, getThis(), ISV(label)));
if (!zend_is_true(&label)) {
PHALCON_CALL_METHODW(&label, validator, "getlabel", attribute);
if (!zend_is_true(&label)) {
PHALCON_CPY_WRT_CTOR(&label, attribute);
}
}
RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&code, ce, getThis(), ISV(code)));
if (Z_TYPE(code) == IS_NULL) {
ZVAL_LONG(&code, 0);
}
array_init(&pairs);
phalcon_array_update_str(&pairs, SL(":field"), &label, PH_COPY);
if (phalcon_compare_strict_string(&type, SL("TooLarge"))) {
phalcon_array_update_str(&pairs, SL(":max"), &maxsize, PH_COPY);
RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&message_str, ce, getThis(), ISV(message)));
if (!zend_is_true(&message_str)) {
RETURN_ON_FAILURE(phalcon_validation_getdefaultmessage_helper(&message_str, Z_OBJCE_P(validator), validator, "FileMaxSize"));
}
PHALCON_CALL_FUNCTIONW(&prepared, "strtr", &message_str, &pairs);
phalcon_validation_message_construct_helper(&message, &prepared, attribute, "TooLarge", &code);
} else if (phalcon_compare_strict_string(&type, SL("TooSmall"))) {
phalcon_array_update_str(&pairs, SL(":min"), &minsize, PH_COPY);
RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&message_str, ce, getThis(), ISV(message)));
if (!zend_is_true(&message_str)) {
RETURN_ON_FAILURE(phalcon_validation_getdefaultmessage_helper(&message_str, Z_OBJCE_P(validator), validator, "FileMinSize"));
}
PHALCON_CALL_FUNCTIONW(&prepared, "strtr", &message_str, &pairs);
phalcon_validation_message_construct_helper(&message, &prepared, attribute, "TooSmall", &code);
} else if (phalcon_compare_strict_string(&type, SL("MimeValid"))) {
phalcon_fast_join_str(&join_mimes, SL(", "), &mimes);
phalcon_array_update_str(&pairs, SL(":mimes"), &join_mimes, PH_COPY);
RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&message_str, ce, getThis(), ISV(message)));
if (!zend_is_true(&message_str)) {
RETURN_ON_FAILURE(phalcon_validation_getdefaultmessage_helper(&message_str, Z_OBJCE_P(validator), validator, "FileType"));
}
PHALCON_CALL_FUNCTIONW(&prepared, "strtr", &message_str, &pairs);
phalcon_validation_message_construct_helper(&message, &prepared, attribute, "FileType", &code);
} else if (phalcon_compare_strict_string(&type, SL("TooLarge"))) {
phalcon_array_update_str(&pairs, SL(":max"), &maxsize, PH_COPY);
RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&message_str, ce, getThis(), ISV(message)));
if (!zend_is_true(&message_str)) {
RETURN_ON_FAILURE(phalcon_validation_getdefaultmessage_helper(&message_str, Z_OBJCE_P(validator), validator, "FileMaxSize"));
}
PHALCON_CALL_FUNCTIONW(&prepared, "strtr", &message_str, &pairs);
phalcon_validation_message_construct_helper(&message, &prepared, attribute, "TooLarge", &code);
} else if (phalcon_compare_strict_string(&type, SL("TooNarrow"))) {
phalcon_array_update_str(&pairs, SL(":min"), &minwidth, PH_COPY);
RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&message_str, ce, getThis(), ISV(message)));
if (!zend_is_true(&message_str)) {
RETURN_ON_FAILURE(phalcon_validation_getdefaultmessage_helper(&message_str, Z_OBJCE_P(validator), validator, "ImageMinWidth"));
}
PHALCON_CALL_FUNCTIONW(&prepared, "strtr", &message_str, &pairs);
phalcon_validation_message_construct_helper(&message, &prepared, attribute, "TooNarrow", &code);
} else if (phalcon_compare_strict_string(&type, SL("TooWide"))) {
phalcon_array_update_str(&pairs, SL(":max"), &maxwidth, PH_COPY);
RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&message_str, ce, getThis(), ISV(message)));
if (!zend_is_true(&message_str)) {
RETURN_ON_FAILURE(phalcon_validation_getdefaultmessage_helper(&message_str, Z_OBJCE_P(validator), validator, "ImageMaxWidth"));
}
PHALCON_CALL_FUNCTIONW(&prepared, "strtr", &message_str, &pairs);
phalcon_validation_message_construct_helper(&message, &prepared, attribute, "TooWide", &code);
} else if (phalcon_compare_strict_string(&type, SL("TooShort"))) {
phalcon_array_update_str(&pairs, SL(":min"), &minheight, PH_COPY);
RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&message_str, ce, getThis(), ISV(message)));
if (!zend_is_true(&message_str)) {
RETURN_ON_FAILURE(phalcon_validation_getdefaultmessage_helper(&message_str, Z_OBJCE_P(validator), validator, "ImageMinHeight"));
}
PHALCON_CALL_FUNCTIONW(&prepared, "strtr", &message_str, &pairs);
phalcon_validation_message_construct_helper(&message, &prepared, attribute, "TooShort", &code);
} else if (phalcon_compare_strict_string(&type, SL("TooLong"))) {
phalcon_array_update_str(&pairs, SL(":max"), &maxheight, PH_COPY);
RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&message_str, ce, getThis(), ISV(message)));
if (!zend_is_true(&message_str)) {
RETURN_ON_FAILURE(phalcon_validation_getdefaultmessage_helper(&message_str, Z_OBJCE_P(validator), validator, "ImageMaxHeight"));
}
PHALCON_CALL_FUNCTIONW(&prepared, "strtr", &message_str, &pairs);
phalcon_validation_message_construct_helper(&message, &prepared, attribute, "TooLong", &code);
} else {
RETURN_ON_FAILURE(phalcon_validation_validator_getoption_helper(&message_str, ce, getThis(), ISV(message)));
if (!zend_is_true(&message_str)) {
RETURN_ON_FAILURE(phalcon_validation_getdefaultmessage_helper(&message_str, Z_OBJCE_P(validator), validator, "FileValid"));
}
PHALCON_CALL_FUNCTIONW(&prepared, "strtr", &message_str, &pairs);
phalcon_validation_message_construct_helper(&message, &prepared, attribute, "File", &code);
}
PHALCON_CALL_METHODW(NULL, validator, "appendmessage", &message);
RETURN_FALSE;
}
RETURN_TRUE;
}
/**
* Gets the a value to validate in the array/object data source
*
* @param string $attribute
* @return mixed
*/
PHP_METHOD(Phalcon_Validation, getValue){
zval *attribute, *entity, *method, *value = NULL, *data, *values;
zval *filters, *field_filters, *service_name;
zval *dependency_injector = NULL, *filter_service;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &attribute);
PHALCON_OBS_VAR(entity);
phalcon_read_property_this(&entity, this_ptr, SL("_entity"), PH_NOISY_CC);
/**
* If the entity is an object use it to retrieve the values
*/
if (Z_TYPE_P(entity) == IS_OBJECT) {
PHALCON_INIT_VAR(method);
PHALCON_CONCAT_SV(method, "get", attribute);
if (phalcon_method_exists(entity, method TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(value);
phalcon_call_method_zval(value, entity, method);
} else if (phalcon_method_exists_ex(entity, SS("readattribute") TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(value);
phalcon_call_method_p1(value, entity, "readattribute", attribute);
} else if (phalcon_isset_property_zval(entity, attribute TSRMLS_CC)) {
PHALCON_OBS_VAR(value);
phalcon_read_property_zval(&value, entity, attribute, PH_NOISY_CC);
} else {
PHALCON_INIT_VAR(value);
}
RETURN_CCTOR(value);
}
PHALCON_OBS_VAR(data);
phalcon_read_property_this(&data, this_ptr, SL("_data"), PH_NOISY_CC);
if (Z_TYPE_P(data) != IS_ARRAY) {
if (Z_TYPE_P(data) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "There is no data to validate");
return;
}
}
/**
* Check if there is a calculated value
*/
PHALCON_OBS_VAR(values);
phalcon_read_property_this(&values, this_ptr, SL("_values"), PH_NOISY_CC);
if (phalcon_array_isset(values, attribute)) {
PHALCON_OBS_NVAR(value);
phalcon_array_fetch(&value, values, attribute, PH_NOISY);
RETURN_CCTOR(value);
}
PHALCON_INIT_NVAR(value);
if (Z_TYPE_P(data) == IS_ARRAY) {
if (phalcon_array_isset(data, attribute)) {
PHALCON_OBS_NVAR(value);
phalcon_array_fetch(&value, data, attribute, PH_NOISY);
}
} else {
if (Z_TYPE_P(data) == IS_OBJECT) {
if (phalcon_isset_property_zval(data, attribute TSRMLS_CC)) {
PHALCON_OBS_NVAR(value);
phalcon_read_property_zval(&value, data, attribute, PH_NOISY_CC);
}
}
}
if (Z_TYPE_P(value) != IS_NULL) {
PHALCON_OBS_VAR(filters);
phalcon_read_property_this(&filters, this_ptr, SL("_filters"), PH_NOISY_CC);
if (Z_TYPE_P(filters) == IS_ARRAY) {
if (phalcon_array_isset(filters, attribute)) {
PHALCON_OBS_VAR(field_filters);
phalcon_array_fetch(&field_filters, filters, attribute, PH_NOISY);
if (zend_is_true(field_filters)) {
PHALCON_INIT_VAR(service_name);
ZVAL_STRING(service_name, "filter", 1);
PHALCON_INIT_VAR(dependency_injector);
phalcon_call_method(dependency_injector, this_ptr, "getdi");
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_INIT_NVAR(dependency_injector);
PHALCON_CALL_STATIC(dependency_injector, "phalcon\\di", "getdefault");
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "A dependency injector is required to obtain the 'filter' service");
return;
}
}
PHALCON_INIT_VAR(filter_service);
phalcon_call_method_p1(filter_service, dependency_injector, "getshared", service_name);
if (Z_TYPE_P(filter_service) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "Returned 'filter' service is invalid");
return;
}
PHALCON_VERIFY_INTERFACE(filter_service, phalcon_filterinterface_ce);
phalcon_call_method_p2(return_value, filter_service, "sanitize", value, field_filters);
RETURN_MM();
}
}
}
/**
* Cache the calculated value
*/
phalcon_update_property_array(this_ptr, SL("_values"), attribute, value TSRMLS_CC);
RETURN_CCTOR(value);
}
RETURN_MM_NULL();
}
/**
* Checks if a role has access to a resource
*
* @param string $roleName
* @param string $resourceName
* @param string $access
* @param string $action
*/
PHP_METHOD(Phalcon_Acl_Adapter_Memory, _allowOrDeny){
zval *role_name, *resource_name, *access, *action;
zval *roles_names, *exception_message = NULL, *resources_names;
zval *default_access, *access_list, *internal_access;
zval *access_name = NULL, *access_key = NULL, *access_key_all = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 4, 0, &role_name, &resource_name, &access, &action);
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_name)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Role \"", role_name, "\" does not exist in ACL");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_acl_exception_ce, exception_message);
return;
}
PHALCON_OBS_VAR(resources_names);
phalcon_read_property_this(&resources_names, this_ptr, SL("_resourcesNames"), PH_NOISY_CC);
if (!phalcon_array_isset(resources_names, resource_name)) {
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Resource \"", resource_name, "\" does not exist in ACL");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_acl_exception_ce, exception_message);
return;
}
PHALCON_OBS_VAR(default_access);
phalcon_read_property_this(&default_access, this_ptr, SL("_defaultAccess"), PH_NOISY_CC);
PHALCON_OBS_VAR(access_list);
phalcon_read_property_this(&access_list, this_ptr, SL("_accessList"), PH_NOISY_CC);
PHALCON_OBS_VAR(internal_access);
phalcon_read_property_this(&internal_access, this_ptr, SL("_access"), PH_NOISY_CC);
if (Z_TYPE_P(access) == IS_ARRAY) {
phalcon_is_iterable(access, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(access_name);
PHALCON_INIT_NVAR(access_key);
PHALCON_CONCAT_VSV(access_key, resource_name, "!", access_name);
if (!phalcon_array_isset(access_list, access_key)) {
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVSVS(exception_message, "Acccess '", access_name, "' does not exist in resource '", resource_name, "'");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_acl_exception_ce, exception_message);
return;
}
zend_hash_move_forward_ex(ah0, &hp0);
}
phalcon_is_iterable(access, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HVALUE(access_name);
PHALCON_INIT_NVAR(access_key);
PHALCON_CONCAT_VSVSV(access_key, role_name, "!", resource_name, "!", access_name);
phalcon_update_property_array(this_ptr, SL("_access"), access_key, action TSRMLS_CC);
if (!PHALCON_IS_STRING(access_name, "*")) {
PHALCON_INIT_NVAR(access_key_all);
PHALCON_CONCAT_VSVS(access_key_all, role_name, "!", resource_name, "!*");
if (!phalcon_array_isset(internal_access, access_key_all)) {
phalcon_update_property_array(this_ptr, SL("_access"), access_key_all, default_access TSRMLS_CC);
}
}
zend_hash_move_forward_ex(ah1, &hp1);
}
} else {
if (!PHALCON_IS_STRING(access, "*")) {
PHALCON_INIT_NVAR(access_key);
PHALCON_CONCAT_VSV(access_key, resource_name, "!", access);
if (!phalcon_array_isset(access_list, access_key)) {
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVSVS(exception_message, "Acccess '", access, "' does not exist in resource '", resource_name, "'");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_acl_exception_ce, exception_message);
return;
}
}
PHALCON_INIT_NVAR(access_key);
PHALCON_CONCAT_VSVSV(access_key, role_name, "!", resource_name, "!", access);
/**
* Define the access action for the specified accessKey
*/
phalcon_update_property_array(this_ptr, SL("_access"), access_key, action TSRMLS_CC);
if (!PHALCON_IS_STRING(access, "*")) {
PHALCON_INIT_NVAR(access_key);
PHALCON_CONCAT_VSVS(access_key, role_name, "!", resource_name, "!*");
/**
* If there is no default action for all the rest actions in the resource set the
* default one
*/
if (!phalcon_array_isset(internal_access, access_key)) {
phalcon_update_property_array(this_ptr, SL("_access"), access_key, default_access TSRMLS_CC);
}
}
}
PHALCON_MM_RESTORE();
}
/**
* 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);
}
/**
* Gets the type of PHQL queries
*
*
* @return int
*/
PHP_METHOD(Phalcon_Mvc_Model_Query_Builder_Where, setConditions){
zval *conditions, *bind_params = NULL, *bind_types = NULL, *type = NULL, merge = {}, merged_conditions = {}, merged_bind_params = {}, merged_bind_types;
zval joind_condition = {}, *single_condition_array = NULL, current_conditions = {}, new_conditions = {};
zend_string *str_key;
ulong idx;
phalcon_fetch_params(0, 1, 3, &conditions, &bind_params, &bind_types, &type);
if (!bind_params) {
bind_params = &PHALCON_GLOBAL(z_null);
}
if (!bind_types) {
bind_types = &PHALCON_GLOBAL(z_null);
}
if (!type) {
type = &PHALCON_GLOBAL(z_null);
}
ZVAL_BOOL(&merge, Z_TYPE_P(type) != IS_NULL ? 1 : 0);
if (Z_TYPE_P(conditions) == IS_ARRAY) {
/* ----------- INITIALIZING LOOP VARIABLES ----------- */
/*
* array containing single condition for example:
* array(
* array(
* 'status = :status:',
* array('status' => 5),
* array('status' => PDO::PARAM_INT),
* ),
* 'name' => 'Dreamsxin',
* )
*/
array_init(&merged_conditions);
array_init(&merged_bind_params);
array_init(&merged_bind_types);
ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(conditions), idx, str_key, single_condition_array) {
zval single_condition_key = {}, condition_string = {}, tmp_bind_params = {}, tmp_bind_types = {};
if (str_key) {
ZVAL_STR(&single_condition_key, str_key);
} else {
ZVAL_LONG(&single_condition_key, idx);
}
if (Z_TYPE_P(single_condition_array) == IS_ARRAY
&& phalcon_array_isset_fetch_long(&condition_string, single_condition_array, 0)
&& phalcon_array_isset_fetch_long(&tmp_bind_params, single_condition_array, 1)
&& Z_TYPE(condition_string) == IS_STRING
&& Z_TYPE(tmp_bind_params) == IS_ARRAY
) {
phalcon_array_update_zval(&merged_conditions, &condition_string, &condition_string, PH_COPY);
phalcon_array_merge_recursive_n(&merged_bind_params, &tmp_bind_params);
if (phalcon_array_isset_fetch_long(&tmp_bind_types, single_condition_array, 2) && Z_TYPE(tmp_bind_types) == IS_ARRAY) {
phalcon_array_merge_recursive_n(&merged_bind_types, &tmp_bind_types);
}
} else if (Z_TYPE(single_condition_key) == IS_STRING) {
PHALCON_CONCAT_VSVS(&condition_string, &single_condition_key, " = :", &single_condition_key, ":");
phalcon_array_update_zval(&merged_conditions, &single_condition_key, &condition_string, PH_COPY);
if (Z_TYPE_P(single_condition_array) == IS_ARRAY) {
phalcon_array_merge_recursive_n(&merged_bind_params, single_condition_array);
} else {
phalcon_array_update_zval(&merged_bind_params, &single_condition_key, single_condition_array, PH_COPY);
}
}
} ZEND_HASH_FOREACH_END();
/**
* Magic method to get or set services using setters/getters
*
* @param string $method
* @param array $arguments
* @return mixed
*/
PHP_METHOD(Phalcon_DI, __call){
zval *method, *arguments = NULL, *services, *service_name = NULL;
zval *possible_service = NULL, *instance = NULL, *handler;
zval *exception_message;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &method, &arguments);
if (!arguments) {
PHALCON_INIT_VAR(arguments);
}
/**
* If the magic method starts with 'get' we try to get a service with that name
*/
if (phalcon_start_with_str(method, SL("get"))) {
PHALCON_OBS_VAR(services);
phalcon_read_property_this(&services, this_ptr, SL("_services"), PH_NOISY_CC);
PHALCON_INIT_VAR(service_name);
phalcon_substr(service_name, method, 3, 0 TSRMLS_CC);
PHALCON_INIT_VAR(possible_service);
PHALCON_CALL_FUNC_PARAMS_1(possible_service, "lcfirst", service_name);
if (phalcon_array_isset(services, possible_service)) {
if (phalcon_fast_count_ev(arguments TSRMLS_CC)) {
PHALCON_INIT_VAR(instance);
PHALCON_CALL_METHOD_PARAMS_2(instance, this_ptr, "get", possible_service, arguments);
} else {
PHALCON_INIT_NVAR(instance);
PHALCON_CALL_METHOD_PARAMS_1(instance, this_ptr, "get", possible_service);
}
RETURN_CCTOR(instance);
}
}
/**
* If the magic method starts with 'set' we try to set a service using that name
*/
if (phalcon_start_with_str(method, SL("set"))) {
if (phalcon_array_isset_long(arguments, 0)) {
PHALCON_INIT_NVAR(service_name);
phalcon_substr(service_name, method, 3, 0 TSRMLS_CC);
PHALCON_INIT_NVAR(possible_service);
PHALCON_CALL_FUNC_PARAMS_1(possible_service, "lcfirst", service_name);
PHALCON_OBS_VAR(handler);
phalcon_array_fetch_long(&handler, arguments, 0, PH_NOISY_CC);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "set", possible_service, handler);
RETURN_MM_NULL();
}
}
/**
* The method doesn't start with set/get throw an exception
*/
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Call to undefined method or service '", method, "'");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_di_exception_ce, exception_message);
return;
}
/**
* Executes the validation
*
* @param Phalcon\Validation $validator
* @param string $attribute
* @return boolean
*/
PHP_METHOD(Phalcon_Validation_Validator_StringLength, validate){
zval *validator, *attribute, *value = NULL, *allow_empty;
zval *valid = NULL, *type, *maximum, *minimum, *label;
zval *code, *pairs, *message_str = NULL, *prepared = NULL, *message;
zend_class_entry *ce = Z_OBJCE_P(getThis());
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &validator, &attribute);
PHALCON_VERIFY_CLASS_EX(validator, phalcon_validation_ce, phalcon_validation_exception_ce, 1);
PHALCON_CALL_METHOD(&value, validator, "getvalue", attribute);
PHALCON_OBS_VAR(allow_empty);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &allow_empty, getThis(), ISV(allowEmpty)));
if (zend_is_true(allow_empty) && phalcon_validation_validator_isempty_helper(value)) {
RETURN_MM_TRUE;
}
PHALCON_OBS_VAR(maximum);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &maximum, getThis(), "max"));
PHALCON_OBS_VAR(minimum);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &minimum, getThis(), "min"));
PHALCON_CALL_SELF(&valid, "valid", value, minimum, maximum);
if (PHALCON_IS_FALSE(valid)) {
type = phalcon_read_property(getThis(), SL("_type"), PH_NOISY);
PHALCON_OBS_VAR(label);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &label, getThis(), ISV(label)));
if (!zend_is_true(label)) {
PHALCON_CALL_METHOD(&label, validator, "getlabel", attribute);
if (!zend_is_true(label)) {
PHALCON_CPY_WRT(label, attribute);
}
}
PHALCON_OBS_VAR(code);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &code, getThis(), ISV(code)));
if (Z_TYPE_P(code) == IS_NULL) {
ZVAL_LONG(code, 0);
}
if (phalcon_compare_strict_string(type, SL("TooLong"))) {
PHALCON_ALLOC_INIT_ZVAL(pairs);
array_init_size(pairs, 2);
Z_TRY_ADDREF_P(label); add_assoc_zval_ex(pairs, SL(":field"), label);
Z_TRY_ADDREF_P(maximum); add_assoc_zval_ex(pairs, SL(":max"), maximum);
PHALCON_OBS_VAR(message_str);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &message_str, getThis(), "messageMaximum"));
if (!zend_is_true(message_str)) {
PHALCON_OBSERVE_OR_NULLIFY_VAR(message_str);
RETURN_MM_ON_FAILURE(phalcon_validation_getdefaultmessage_helper(Z_OBJCE_P(validator), message_str, validator, "TooLong"));
}
PHALCON_CALL_FUNCTION(&prepared, "strtr", message_str, pairs);
message = phalcon_validation_message_construct_helper(prepared, attribute, "TooLong", code);
} else {
PHALCON_ALLOC_INIT_ZVAL(pairs);
array_init_size(pairs, 2);
Z_TRY_ADDREF_P(label); add_assoc_zval_ex(pairs, SL(":field"), label);
Z_TRY_ADDREF_P(minimum); add_assoc_zval_ex(pairs, SL(":min"), minimum);
PHALCON_OBS_VAR(message_str);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &message_str, getThis(), "messageMinimum"));
if (!zend_is_true(message_str)) {
PHALCON_OBSERVE_OR_NULLIFY_VAR(message_str);
RETURN_MM_ON_FAILURE(phalcon_validation_getdefaultmessage_helper(Z_OBJCE_P(validator), message_str, validator, "TooShort"));
}
PHALCON_CALL_FUNCTION(&prepared, "strtr", message_str, pairs);
message = phalcon_validation_message_construct_helper(prepared, attribute, "TooShort", code);
}
Z_TRY_DELREF_P(message);
PHALCON_CALL_METHOD(NULL, validator, "appendmessage", message);
RETURN_MM_FALSE;
}
RETURN_MM_TRUE;
}
/**
* Prepare an HTML string of information about a single variable.
*/
PHP_METHOD(Phalcon_Debug_Dump, output){
zval *variable, *name = NULL, *tab = NULL, *space, *tmp = NULL, *new_tab = NULL;
zval *output = NULL, *str = NULL, *type = NULL, *style = NULL, *count = NULL, *key = NULL, *value = NULL, *replace_pairs = NULL;
zval *class_name = NULL, *objects, *detailed = NULL, *properties = NULL, *methods = NULL, *method = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 2, &variable, &name, &tab);
if (!name) {
name = PHALCON_GLOBAL(z_null);
} else if (!PHALCON_IS_EMPTY(name)) {
PHALCON_CONCAT_SVS(return_value, "var ", name, " ");
}
if (!tab) {
tab = PHALCON_GLOBAL(z_one);
}
PHALCON_INIT_VAR(space);
ZVAL_STRING(space, " ", 1);
if (Z_TYPE_P(variable) == IS_ARRAY) {
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "<b style =':style'>Array</b> (<span style =':style'>:count</span>) (\n", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "arr", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(count);
ZVAL_LONG(count, phalcon_fast_count_int(variable TSRMLS_CC));
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":count"), count, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
phalcon_concat_self(&return_value, output TSRMLS_CC);
phalcon_is_iterable(variable, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(key, ah0, hp0);
PHALCON_GET_HVALUE(value);
PHALCON_CALL_FUNCTION(&tmp, "str_repeat", space, tab);
phalcon_concat_self(&return_value, tmp TSRMLS_CC);
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "[<span style=':style'>:key</span>] => ", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "arr", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":key"), key, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
phalcon_concat_self(&return_value, output TSRMLS_CC);
if (PHALCON_IS_LONG(tab, 1) && !PHALCON_IS_EMPTY(name) && !phalcon_is_numeric(key) && PHALCON_IS_IDENTICAL(name, key)) {
zend_hash_move_forward_ex(ah0, &hp0);
continue;
} else {
PHALCON_INIT_NVAR(new_tab);
ZVAL_LONG(new_tab, Z_LVAL_P(tab) + 1);
PHALCON_CALL_SELF(&tmp, "output", value, PHALCON_GLOBAL(z_null), new_tab);
PHALCON_SCONCAT_VS(return_value, tmp, "\n");
}
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_NVAR(new_tab);
ZVAL_LONG(new_tab, Z_LVAL_P(tab) - 1);
PHALCON_CALL_FUNCTION(&tmp, "str_repeat", space, tab);
PHALCON_SCONCAT(return_value, tmp);
} else if (Z_TYPE_P(variable) == IS_OBJECT) {
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "<b style=':style'>Object</b> :class", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "obj", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(class_name);
phalcon_get_class(class_name, variable, 0 TSRMLS_CC);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":class"), class_name, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
PHALCON_INIT_NVAR(class_name);
phalcon_get_parent_class(class_name, variable, 0 TSRMLS_CC);
if (zend_is_true(class_name)) {
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, " <b style=':style'>extends</b> :parent", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "obj", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":parent"), class_name, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
}
PHALCON_SCONCAT_STR(return_value, " (\n");
objects = phalcon_fetch_nproperty_this(this_ptr, SL("_objects"), PH_NOISY TSRMLS_CC);
if (phalcon_fast_in_array(variable, objects TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(&tmp, "str_repeat", space, tab);
PHALCON_SCONCAT_VS(return_value, tmp, "[already listed]\n");
PHALCON_INIT_NVAR(new_tab);
ZVAL_LONG(new_tab, Z_LVAL_P(tab) - 1);
PHALCON_CALL_FUNCTION(&tmp, "str_repeat", space, tab);
PHALCON_SCONCAT_VS(return_value, tmp, ")");
RETURN_MM();
}
phalcon_update_property_array_append(this_ptr, SL("_objects"), variable TSRMLS_CC);
detailed = phalcon_fetch_nproperty_this(this_ptr, SL("_detailed"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_NVAR(properties);
phalcon_get_object_vars(properties, variable, !zend_is_true(detailed) TSRMLS_CC);
phalcon_is_iterable(properties, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(key, ah0, hp0);
PHALCON_GET_HVALUE(value);
PHALCON_CALL_FUNCTION(&tmp, "str_repeat", space, tab);
PHALCON_SCONCAT(return_value, tmp);
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "-><span style=':style'>:key</span> (<span style=':style'>:type</span>) = ", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "obj", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":key"), key, PH_COPY);
if (PHALCON_PROPERTY_IS_PUBLIC_ZVAL(variable, key)) {
phalcon_array_update_string_string(&replace_pairs, SL(":type"), SL("public"), PH_COPY);
} else if (PHALCON_PROPERTY_IS_PRIVATE_ZVAL(variable, key)) {
phalcon_array_update_string_string(&replace_pairs, SL(":type"), SL("private"), PH_COPY);
} else if (PHALCON_PROPERTY_IS_PROTECTED_ZVAL(variable, key)) {
phalcon_array_update_string_string(&replace_pairs, SL(":type"), SL("protected"), PH_COPY);
}
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
PHALCON_INIT_NVAR(new_tab);
ZVAL_LONG(new_tab, Z_LVAL_P(tab) + 1);
PHALCON_CALL_SELF(&tmp, "output", value, PHALCON_GLOBAL(z_null), new_tab);
PHALCON_SCONCAT_VS(return_value, tmp, ")\n");
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_NVAR(methods);
phalcon_get_class_methods(methods, variable, !zend_is_true(detailed) TSRMLS_CC);
PHALCON_CALL_FUNCTION(&tmp, "str_repeat", space, tab);
PHALCON_SCONCAT(return_value, tmp);
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, ":class <b style=':style'>methods</b>: (<span style=':style'>:count</span>) (\n", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "obj", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(class_name);
phalcon_get_class(class_name, variable, 0 TSRMLS_CC);
PHALCON_INIT_NVAR(count);
ZVAL_LONG(count, phalcon_fast_count_int(methods TSRMLS_CC));
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":class"), class_name, PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":count"), count, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
phalcon_is_iterable(methods, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(method);
PHALCON_INIT_NVAR(new_tab);
ZVAL_LONG(new_tab, Z_LVAL_P(tab) + 1);
PHALCON_CALL_FUNCTION(&tmp, "str_repeat", space, new_tab);
PHALCON_SCONCAT(return_value, tmp);
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "-><span style=':style'>:method</span>();\n", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "obj", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":method"), method, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
PHALCON_CALL_FUNCTION(&tmp, "str_repeat", space, tab);
PHALCON_SCONCAT_VS(return_value, tmp, "\n");
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_NVAR(new_tab);
ZVAL_LONG(new_tab, Z_LVAL_P(tab) - 1);
PHALCON_CALL_FUNCTION(&tmp, "str_repeat", space, tab);
PHALCON_SCONCAT_VS(return_value, tmp, ")");
} else if (Z_TYPE_P(variable) == IS_LONG) {
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "<b style=':style'>Integer</b> (<span style=':style'>:var</span>)", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "int", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":var"), variable, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
} else if (Z_TYPE_P(variable) == IS_DOUBLE) {
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "<b style=':style'>Float</b> (<span style=':style'>:var</span>)", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "float", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":var"), variable, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
} else if (phalcon_is_numeric_ex(variable)) {
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "<b style=':style'>Numeric string</b> (<span style=':style'>:length</span>) \"<span style=':style'>:var</span>\"", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "num", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string_long(&replace_pairs, SL(":length"), Z_STRLEN_P(variable), PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":var"), variable, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
} else if (Z_TYPE_P(variable) == IS_STRING) {
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "<b style=':style'>String</b> (<span style=':style'>:length</span>) \"<span style=':style'>:var</span>\"", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "str", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string_long(&replace_pairs, SL(":length"), Z_STRLEN_P(variable), PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":var"), variable, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
} else if (Z_TYPE_P(variable) == IS_BOOL) {
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "<b style=':style'>Boolean</b> (<span style=':style'>:var</span>)", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "bool", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
if (zend_is_true(variable)) {
phalcon_array_update_string_string(&replace_pairs, SL(":var"), SL("TRUE") , PH_COPY);
} else {
phalcon_array_update_string_string(&replace_pairs, SL(":var"), SL("FALSE") , PH_COPY);
}
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
} else if (Z_TYPE_P(variable) == IS_NULL) {
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "<b style=':style'>NULL</b>", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "null", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
} else {
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "(<span style=':style'>:var</span>)", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "other", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":var"), variable, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
}
RETURN_MM();
}
PHP_METHOD(Phalcon_Http_Client_Adapter_Curl, __construct){
zval *uri = NULL, *method = NULL, *upper_method, *header, *curl = NULL, *options, *constant;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 2, &uri, &method);
if (uri) {
PHALCON_CALL_SELF(NULL, "setbaseuri", uri);
}
if (method) {
PHALCON_INIT_VAR(upper_method);
phalcon_fast_strtoupper(upper_method, method);
phalcon_update_property_this(this_ptr, SL("_method"), upper_method TSRMLS_CC);
}
PHALCON_INIT_VAR(header);
object_init_ex(header, phalcon_http_client_header_ce);
PHALCON_CALL_METHOD(NULL, header, "__construct");
phalcon_update_property_this(this_ptr, SL("_header"), header TSRMLS_CC);
PHALCON_CALL_FUNCTION(&curl, "curl_init");
PHALCON_INIT_VAR(options);
array_init(options);
PHALCON_INIT_VAR(constant);
if (zend_get_constant(SL("CURLOPT_RETURNTRANSFER"), constant TSRMLS_CC)) {
phalcon_array_update_zval_bool(&options, constant, 1, PH_COPY);
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_AUTOREFERER"), constant TSRMLS_CC)) {
phalcon_array_update_zval_bool(&options, constant, 1, PH_COPY);
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_FOLLOWLOCATION"), constant TSRMLS_CC)) {
phalcon_array_update_zval_bool(&options, constant, 1, PH_COPY);
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_MAXREDIRS"), constant TSRMLS_CC)) {
phalcon_array_update_zval_long(&options, constant, 20, PH_COPY);
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_HEADER"), constant TSRMLS_CC)) {
phalcon_array_update_zval_bool(&options, constant, 1, PH_COPY);
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_USERAGENT"), constant TSRMLS_CC)) {
phalcon_array_update_zval_string(&options, constant, SL("Phalcon HTTP Client(Curl)"), PH_COPY);
}
PHALCON_CALL_FUNCTION(NULL, "curl_setopt_array", curl, options);
phalcon_update_property_this(this_ptr, SL("_curl"), curl TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Phalcon\Config\Adapter\Ini constructor
*
* @param string $filePath
*/
PHP_METHOD(Phalcon_Config_Adapter_Ini, __construct){
zval *file_path, *process_sections, *ini_config;
zval *exception_message, *config, *directives = NULL;
zval *section = NULL, *value = NULL, *key = NULL, *directive_parts = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &file_path);
PHALCON_INIT_VAR(process_sections);
ZVAL_BOOL(process_sections, 1);
/**
* Use the standard parse_ini_file
*/
PHALCON_INIT_VAR(ini_config);
phalcon_call_func_p2(ini_config, "parse_ini_file", file_path, process_sections);
/**
* Check if the file had errors
*/
if (PHALCON_IS_FALSE(ini_config)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Configuration file ", file_path, " can't be loaded");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_config_exception_ce, exception_message);
return;
}
PHALCON_INIT_VAR(config);
array_init(config);
phalcon_is_iterable(ini_config, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(section, ah0, hp0);
PHALCON_GET_HVALUE(directives);
if (unlikely(Z_TYPE_P(directives) != IS_ARRAY)) {
Z_ADDREF_P(directives);
if (phalcon_array_update_zval(&config, section, &directives, 0) != SUCCESS) {
Z_DELREF_P(directives);
}
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
phalcon_is_iterable(directives, &ah1, &hp1, 0, 0);
if (zend_hash_num_elements(ah1) == 0) {
Z_ADDREF_P(directives);
phalcon_array_update_zval(&config, section, &directives, 0);
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HKEY(key, ah1, hp1);
PHALCON_GET_HVALUE(value);
if (phalcon_memnstr_str(key, SL("."))) {
PHALCON_INIT_NVAR(directive_parts);
phalcon_fast_explode_str(directive_parts, SL("."), key);
phalcon_config_adapter_ini_update_zval_directive(&config, section, directive_parts, &value, 0 TSRMLS_CC);
} else {
phalcon_array_update_multi_2(&config, section, key, &value, 0);
}
zend_hash_move_forward_ex(ah1, &hp1);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
/**
* Calls the Phalcon\Config constructor
*/
PHALCON_CALL_PARENT_PARAMS_1_NORETURN(this_ptr, "Phalcon\\Config\\Adapter\\Ini", "__construct", config);
PHALCON_MM_RESTORE();
}
/**
* 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;
}
/**
* Magic method __get
*
* @param string $propertyName
*/
PHP_METHOD(Phalcon_DI_Injectable, __get){
zval *property_name, *dependency_injector = NULL;
zval *has_service, *service = NULL, *class_name, *arguments;
zval *persistent;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &property_name);
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_INIT_NVAR(dependency_injector);
PHALCON_CALL_STATIC(dependency_injector, "phalcon\\di", "getdefault");
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_di_exception_ce, "A dependency injection object is required to access the application services");
return;
}
}
/**
* Fallback to the PHP userland if the cache is not available
*/
PHALCON_INIT_VAR(has_service);
phalcon_call_method_p1(has_service, dependency_injector, "has", property_name);
if (zend_is_true(has_service)) {
PHALCON_INIT_VAR(service);
phalcon_call_method_p1(service, dependency_injector, "getshared", property_name);
phalcon_update_property_zval_zval(this_ptr, property_name, service TSRMLS_CC);
RETURN_CCTOR(service);
}
if (PHALCON_IS_STRING(property_name, "di")) {
phalcon_update_property_this(this_ptr, SL("di"), dependency_injector TSRMLS_CC);
RETURN_CCTOR(dependency_injector);
}
/**
* Accessing the persistent property will create a session bag in any class
*/
if (PHALCON_IS_STRING(property_name, "persistent")) {
PHALCON_INIT_VAR(class_name);
phalcon_get_class(class_name, this_ptr, 0 TSRMLS_CC);
PHALCON_INIT_VAR(arguments);
array_init_size(arguments, 1);
phalcon_array_append(&arguments, class_name, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_NVAR(service);
ZVAL_STRING(service, "sessionBag", 1);
PHALCON_INIT_VAR(persistent);
phalcon_call_method_p2(persistent, dependency_injector, "get", service, arguments);
phalcon_update_property_this(this_ptr, SL("persistent"), persistent TSRMLS_CC);
RETURN_CCTOR(persistent);
}
/**
* A notice is shown if the property is not defined and isn't a valid service
*/
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Access to undefined property %s", Z_STRVAL_P(property_name));
RETURN_MM_NULL();
}
/**
* Executes the validator
*
* @param Phalcon\Mvc\ModelInterface $record
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator_Url, validate){
zval *record, *option = NULL, *field = NULL, *value = NULL, *flag, *is_valid = NULL;
zval *message = NULL, *type, *is_set_code = NULL, *code;
zval *allow_empty = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &record);
PHALCON_INIT_VAR(option);
ZVAL_STRING(option, "field", 1);
PHALCON_CALL_METHOD(&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_CALL_METHOD(&value, record, "readattribute", field);
/*
* Allow empty
*/
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "allowEmpty", 1);
PHALCON_CALL_METHOD(&allow_empty, this_ptr, "getoption", option);
if (allow_empty && zend_is_true(allow_empty) && PHALCON_IS_EMPTY(value)) {
RETURN_MM_TRUE;
}
PHALCON_INIT_VAR(flag);
ZVAL_LONG(flag, 273);
/**
* Filters the format using FILTER_VALIDATE_URL
*/
PHALCON_CALL_FUNCTION(&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);
PHALCON_ZVAL_MAYBE_INTERNED_STRING(option, phalcon_interned_message);
PHALCON_CALL_METHOD(&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);
/*
* Is code set
*/
PHALCON_INIT_NVAR(option);
PHALCON_ZVAL_MAYBE_INTERNED_STRING(option, phalcon_interned_code);
PHALCON_CALL_METHOD(&is_set_code, this_ptr, "issetoption", option);
if (zend_is_true(is_set_code)) {
PHALCON_CALL_METHOD(&code, this_ptr, "getoption", option);
} else {
PHALCON_INIT_VAR(code);
ZVAL_LONG(code, 0);
}
PHALCON_CALL_METHOD(NULL, this_ptr, "appendmessage", message, field, type, code);
RETURN_MM_FALSE;
}
RETURN_MM_TRUE;
}
/**
* Listens for notifications from the models manager
*
* @param string $type
* @param Phalcon\Mvc\ModelInterface $model
*/
PHP_METHOD(Phalcon_Mvc_Model_Behavior_Timestampable, notify){
zval *type, *model, *take_action, *options, *timestamp = NULL;
zval *format, *generator, *field, *single_field = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &type, &model);
/**
* Check if the developer decided to take action here
*/
PHALCON_INIT_VAR(take_action);
phalcon_call_method_p1(take_action, this_ptr, "musttakeaction", type);
if (PHALCON_IS_NOT_TRUE(take_action)) {
RETURN_MM_NULL();
}
PHALCON_INIT_VAR(options);
phalcon_call_method_p1(options, this_ptr, "getoptions", type);
if (Z_TYPE_P(options) == IS_ARRAY) {
/**
* The field name is required in this behavior
*/
if (!phalcon_array_isset_string(options, SS("field"))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "The option 'field' is required");
return;
}
PHALCON_INIT_VAR(timestamp);
if (phalcon_array_isset_string(options, SS("format"))) {
/**
* Format is a format for date()
*/
PHALCON_OBS_VAR(format);
phalcon_array_fetch_string(&format, options, SL("format"), PH_NOISY_CC);
phalcon_call_func_p1(timestamp, "date", format);
} else {
if (phalcon_array_isset_string(options, SS("generator"))) {
/**
* A generator is a closure that produce the correct timestamp value
*/
PHALCON_OBS_VAR(generator);
phalcon_array_fetch_string(&generator, options, SL("generator"), PH_NOISY_CC);
if (Z_TYPE_P(generator) == IS_OBJECT) {
if (phalcon_is_instance_of(generator, SL("Closure") TSRMLS_CC)) {
PHALCON_INIT_NVAR(timestamp);
PHALCON_CALL_USER_FUNC(timestamp, generator);
}
}
}
}
/**
* Last resort call time()
*/
if (Z_TYPE_P(timestamp) == IS_NULL) {
PHALCON_INIT_NVAR(timestamp);
ZVAL_LONG(timestamp, (long) time(NULL));
}
PHALCON_OBS_VAR(field);
phalcon_array_fetch_string(&field, options, SL("field"), PH_NOISY_CC);
/**
* Assign the value to the field, use writeattribute if the property is protected
*/
if (unlikely(Z_TYPE_P(field) == IS_ARRAY)) {
phalcon_is_iterable(field, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(single_field);
phalcon_call_method_p2_noret(model, "writeattribute", single_field, timestamp);
zend_hash_move_forward_ex(ah0, &hp0);
}
} else {
phalcon_call_method_p2_noret(model, "writeattribute", field, timestamp);
}
}
PHALCON_MM_RESTORE();
}
/**
* 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;
}
/**
* Produces a recursive representation of an array
*
* @param array $argument
* @return string
*/
PHP_METHOD(Phalcon_Debug, _getArrayDump){
zval *argument, *n = NULL, *number_arguments, *one, *dump;
zval *v = NULL, *k = NULL, *var_dump = NULL, *escaped_string = NULL, *next = NULL, *array_dump = NULL;
zval *class_name = NULL, *joined_dump;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &argument, &n);
if (!n) {
PHALCON_INIT_VAR(n);
ZVAL_LONG(n, 0);
}
PHALCON_INIT_VAR(number_arguments);
phalcon_fast_count(number_arguments, argument TSRMLS_CC);
if (PHALCON_LT_LONG(n, 3)) {
if (PHALCON_GT_LONG(number_arguments, 0)) {
if (PHALCON_LT_LONG(number_arguments, 10)) {
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_INIT_VAR(dump);
array_init(dump);
phalcon_is_iterable(argument, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(k, ah0, hp0);
PHALCON_GET_HVALUE(v);
if (PHALCON_IS_SCALAR(v)) {
if (PHALCON_IS_STRING(v, "")) {
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVS(var_dump, "[", k, "] => (empty string)");
} else {
PHALCON_INIT_NVAR(escaped_string);
phalcon_call_method_p1(escaped_string, this_ptr, "_escapestring", v);
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVSV(var_dump, "[", k, "] => ", escaped_string);
}
phalcon_array_append(&dump, var_dump, PH_SEPARATE);
} else {
if (Z_TYPE_P(v) == IS_ARRAY) {
PHALCON_INIT_NVAR(next);
phalcon_add_function(next, n, one TSRMLS_CC);
PHALCON_INIT_NVAR(array_dump);
phalcon_call_method_p2(array_dump, this_ptr, "_getarraydump", v, next);
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVSVS(var_dump, "[", k, "] => Array(", array_dump, ")");
phalcon_array_append(&dump, var_dump, PH_SEPARATE);
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
if (Z_TYPE_P(v) == IS_OBJECT) {
PHALCON_INIT_NVAR(class_name);
phalcon_get_class(class_name, v, 0 TSRMLS_CC);
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVSVS(var_dump, "[", k, "] => Object(", class_name, ")");
phalcon_array_append(&dump, var_dump, PH_SEPARATE);
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
if (Z_TYPE_P(v) == IS_NULL) {
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVS(var_dump, "[", k, "] => null");
phalcon_array_append(&dump, var_dump, PH_SEPARATE);
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVSV(var_dump, "[", k, "] => ", v);
phalcon_array_append(&dump, var_dump, PH_SEPARATE);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(joined_dump);
phalcon_fast_join_str(joined_dump, SL(", "), dump TSRMLS_CC);
RETURN_CTOR(joined_dump);
}
RETURN_NCTOR(number_arguments);
}
}
RETURN_MM_NULL();
}
/**
* Resolves the service based on its configuration
*
* @param string $name
* @param array $parameters
* @return mixed
*/
PHP_METHOD(Phalcon_DI, get){
zval *name, *parameters = NULL, *services, *service, *instance = NULL;
zval *exception_message;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &name, ¶meters);
if (!parameters) {
PHALCON_INIT_VAR(parameters);
}
/**
* A valid service alias is a string
*/
if (Z_TYPE_P(name) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_di_exception_ce, "The service alias 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)) {
/**
* The service is registered in the DI
*/
PHALCON_OBS_VAR(service);
phalcon_array_fetch(&service, services, name, PH_NOISY_CC);
PHALCON_INIT_VAR(instance);
PHALCON_CALL_METHOD_PARAMS_2(instance, service, "resolve", parameters, this_ptr);
} else {
/**
* The DI also acts as builder for any class even if it isn't defined in the DI
*/
if (phalcon_class_exists(name TSRMLS_CC)) {
if (Z_TYPE_P(parameters) == IS_ARRAY) {
if (phalcon_fast_count_ev(parameters TSRMLS_CC)) {
PHALCON_INIT_NVAR(instance);
if (phalcon_create_instance_params(instance, name, parameters TSRMLS_CC) == FAILURE) {
return;
}
} else {
PHALCON_INIT_NVAR(instance);
if (phalcon_create_instance(instance, name TSRMLS_CC) == FAILURE) {
return;
}
}
} else {
PHALCON_INIT_NVAR(instance);
if (phalcon_create_instance(instance, name TSRMLS_CC) == FAILURE) {
return;
}
}
} else {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Service '", name, "' wasn't found in the dependency injection container");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_di_exception_ce, exception_message);
return;
}
}
/**
* Pass the DI itself if the instance implements Phalcon\DI\InjectionAwareInterface
*/
if (Z_TYPE_P(instance) == IS_OBJECT) {
if (phalcon_method_exists_ex(instance, SS("setdi") TSRMLS_CC) == SUCCESS) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(instance, "setdi", this_ptr);
}
}
RETURN_CCTOR(instance);
}
/**
* Produces an string representation of a variable
*
* @param mixed $variable
* @return string
*/
PHP_METHOD(Phalcon_Debug, _getVarDump){
zval *variable, *class_name, *dumped_object;
zval *array_dump = NULL, *dump = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &variable);
if (PHALCON_IS_SCALAR(variable)) {
/**
* Boolean variables are represented as 'true'/'false'
*/
if (Z_TYPE_P(variable) == IS_BOOL) {
if (zend_is_true(variable)) {
RETURN_MM_STRING("true", 1);
} else {
RETURN_MM_STRING("false", 1);
}
}
/**
* String variables are escaped to avoid XSS injections
*/
if (Z_TYPE_P(variable) == IS_STRING) {
phalcon_call_method_p1(return_value, this_ptr, "_escapestring", variable);
RETURN_MM();
}
/**
* Other scalar variables are just converted to strings
*/
RETURN_CCTOR(variable);
}
/**
* If the variable is an object print its class name
*/
if (Z_TYPE_P(variable) == IS_OBJECT) {
PHALCON_INIT_VAR(class_name);
phalcon_get_class(class_name, variable, 0 TSRMLS_CC);
/**
* Try to check for a 'dump' method, this surely produces a better printable
* representation
*/
if (phalcon_method_exists_ex(variable, SS("dump") TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(dumped_object);
phalcon_call_method(dumped_object, variable, "dump");
/**
* dump() must return an array, generate a recursive representation using
* getArrayDump
*/
PHALCON_INIT_VAR(array_dump);
phalcon_call_method_p1(array_dump, this_ptr, "_getarraydump", dumped_object);
PHALCON_INIT_VAR(dump);
PHALCON_CONCAT_SVSVS(dump, "Object(", class_name, ": ", array_dump, ")");
} else {
/**
* If dump() is not available just print the class name
*/
PHALCON_INIT_NVAR(dump);
PHALCON_CONCAT_SVS(dump, "Object(", class_name, ")</span>");
}
RETURN_CTOR(dump);
}
/**
* Recursively process the array and enclose it in Array()
*/
if (Z_TYPE_P(variable) == IS_ARRAY) {
PHALCON_INIT_NVAR(array_dump);
phalcon_call_method_p1(array_dump, this_ptr, "_getarraydump", variable);
PHALCON_CONCAT_SVS(return_value, "Array(", array_dump, ")");
RETURN_MM();
}
/**
* Null variables are represented as 'null'
* Other types are represented by its type
*/
RETURN_MM_STRING(zend_zval_type_name(variable), 1);
}
/**
* Handle the command-line arguments.
*
*
* <code>
* $arguments = array(
* 'task' => 'taskname',
* 'action' => 'action',
* 'params' => array('parameter1', 'parameter2')
* );
* $console->handle($arguments);
* </code>
*
* @param array $arguments
* @return mixed
*/
PHP_METHOD(Phalcon_CLI_Console, handle){
zval *_arguments = NULL, arguments = {}, dependency_injector = {}, events_manager = {}, event_name = {}, service = {}, router = {}, module_name = {};
zval status = {}, modules = {}, exception_msg = {}, module = {}, path = {}, class_name = {}, module_object = {};
zval namespace_name = {}, task_name = {}, action_name = {}, params = {}, dispatcher = {};
phalcon_fetch_params(0, 0, 1, &_arguments);
if (!_arguments) {
array_init(&arguments);
} else {
PHALCON_CPY_WRT(&arguments, _arguments);
}
phalcon_return_property(&events_manager, getThis(), SL("_eventsManager"));
ZVAL_STRING(&service, ISV(router));
PHALCON_CALL_METHODW(&dependency_injector, getThis(), "getdi");
if (Z_TYPE(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_FORMATW(phalcon_cli_console_exception_ce, "A dependency injection container is required to access the '%s' service", Z_STRVAL(service));
return;
}
PHALCON_CALL_METHODW(&router, &dependency_injector, "getshared", &service);
PHALCON_VERIFY_CLASSW(&router, phalcon_cli_router_ce);
PHALCON_CALL_METHODW(NULL, &router, "handle", &arguments);
PHALCON_CALL_METHODW(&module_name, &router, "getmodulename");
if (zend_is_true(&module_name)) {
if (Z_TYPE(events_manager) == IS_OBJECT) {
ZVAL_STRING(&event_name, "console:beforeStartModule");
PHALCON_CALL_METHODW(&status, &events_manager, "fire", &event_name, getThis(), &module_name);
if (PHALCON_IS_FALSE(&status)) {
RETURN_FALSE;
}
}
phalcon_read_property(&modules, getThis(), SL("_modules"), PH_NOISY);
if (!phalcon_array_isset_fetch(&module, &modules, &module_name, 0)) {
PHALCON_CONCAT_SVS(&exception_msg, "Module '", &module_name, "' isn't registered in the console container");
PHALCON_THROW_EXCEPTION_ZVALW(phalcon_cli_console_exception_ce, &exception_msg);
return;
}
if (Z_TYPE_P(&module) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_cli_console_exception_ce, "Invalid module definition path");
return;
}
if (phalcon_array_isset_fetch_str(&path, &module, SL("path"))) {
convert_to_string_ex(&path);
if (phalcon_file_exists(&path) == SUCCESS) {
RETURN_ON_FAILURE(phalcon_require(Z_STRVAL(path)));
} else {
zend_throw_exception_ex(phalcon_cli_console_exception_ce, 0, "Modules definition path '%s' does not exist", Z_STRVAL(path));
return;
}
}
if (!phalcon_array_isset_fetch_str(&class_name, &module, SL("className"))) {
ZVAL_STRING(&class_name, "Module");
}
PHALCON_CALL_METHODW(&module_object, &dependency_injector, "getshared", &class_name);
PHALCON_CALL_METHODW(NULL, &module_object, "registerautoloaders");
PHALCON_CALL_METHODW(NULL, &module_object, "registerservices", &dependency_injector);
if (Z_TYPE(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(getThis(), SL("_moduleObject"), &module_object);
ZVAL_STRING(&event_name, "console:afterStartModule");
PHALCON_CALL_METHODW(&status, &events_manager, "fire", &event_name, getThis(), &module_name);
if (PHALCON_IS_FALSE(&status)) {
RETURN_FALSE;
}
}
}
PHALCON_CALL_METHODW(&namespace_name, &router, "getnamespacename");
PHALCON_CALL_METHODW(&task_name, &router, "gettaskname");
PHALCON_CALL_METHODW(&action_name, &router, "getactionname");
PHALCON_CALL_METHODW(¶ms, &router, "getparams");
ZVAL_STRING(&service, ISV(dispatcher));
PHALCON_CALL_METHODW(&dispatcher, &dependency_injector, "getshared", &service);
PHALCON_VERIFY_INTERFACEW(&dispatcher, phalcon_dispatcherinterface_ce);
PHALCON_CALL_METHODW(NULL, &dispatcher, "setnamespacename", &namespace_name);
PHALCON_CALL_METHODW(NULL, &dispatcher, "settaskname", &task_name);
PHALCON_CALL_METHODW(NULL, &dispatcher, "setactionname", &action_name);
PHALCON_CALL_METHODW(NULL, &dispatcher, "setparams", ¶ms);
if (Z_TYPE(events_manager) == IS_OBJECT) {
ZVAL_STRING(&event_name, "console:beforeHandleTask");
PHALCON_CALL_METHODW(&status, &events_manager, "fire", &event_name, getThis(), &dispatcher);
if (PHALCON_IS_FALSE(&status)) {
RETURN_FALSE;
}
}
PHALCON_CALL_METHODW(&status, &dispatcher, "dispatch");
if (Z_TYPE(events_manager) == IS_OBJECT) {
ZVAL_STRING(&event_name, "console:afterHandleTask");
PHALCON_CALL_METHODW(NULL, &events_manager, "fire", &event_name, getThis(), &status);
}
RETURN_CTORW(&status);
}
/**
* Shows a backtrace item
*
* @param int $n
* @param array $trace
*/
PHP_METHOD(Phalcon_Debug, showTraceItem){
zval *n, *trace, *space, *two_spaces, *underscore;
zval *minus, *html, *class_name, *pattern, *is_phalcon_class;
zval *namespace_separator, *prepare_uri_class;
zval *class_reflection, *is_internal = NULL, *lower_class_name;
zval *prepare_internal_class, *type, *function_name = NULL;
zval *function_reflection, *prepared_function_name;
zval *trace_args, *arguments, *argument = NULL, *dumped_argument = NULL;
zval *span_argument = NULL, *joined_arguments, *one;
zval *file, *line, *show_files, *lines, *number_lines;
zval *show_file_fragment, *seven, *before_line;
zval *first_line = NULL, *five, *after_line, *last_line = NULL;
zval *comment_pattern, *utf8, *ent_compat, *tab;
zval *comment, *i = NULL, *line_position = NULL, *current_line = NULL;
zval *trimmed = NULL, *is_comment = NULL, *spaced_current_line = NULL;
zval *escaped_line = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
zend_class_entry *ce0, *ce1;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &n, &trace);
PHALCON_INIT_VAR(space);
ZVAL_STRING(space, " ", 1);
PHALCON_INIT_VAR(two_spaces);
ZVAL_STRING(two_spaces, " ", 1);
PHALCON_INIT_VAR(underscore);
ZVAL_STRING(underscore, "_", 1);
PHALCON_INIT_VAR(minus);
ZVAL_STRING(minus, "-", 1);
/**
* Every trace in the backtrace have a unique number
*/
PHALCON_INIT_VAR(html);
PHALCON_CONCAT_SVS(html, "<tr><td align=\"right\" valign=\"top\" class=\"error-number\">#", n, "</td><td>");
if (phalcon_array_isset_string(trace, SS("class"))) {
PHALCON_OBS_VAR(class_name);
phalcon_array_fetch_string(&class_name, trace, SL("class"), PH_NOISY);
PHALCON_INIT_VAR(pattern);
ZVAL_STRING(pattern, "/^Phalcon/", 1);
PHALCON_INIT_VAR(is_phalcon_class);
phalcon_preg_match(is_phalcon_class, pattern, class_name, NULL TSRMLS_CC);
/**
* We assume that classes starting by Phalcon are framework's classes
*/
if (zend_is_true(is_phalcon_class)) {
PHALCON_INIT_VAR(namespace_separator);
ZVAL_STRING(namespace_separator, "\\", 1);
/**
* Prepare the class name according to the Phalcon's conventions
*/
PHALCON_INIT_VAR(prepare_uri_class);
phalcon_fast_str_replace(prepare_uri_class, namespace_separator, underscore, class_name);
/**
* Generate a link to the official docs
*/
PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-class\"><a target=\"_new\" href=\"http://docs.phalconphp.com/en/latest/api/", prepare_uri_class, ".html\">", class_name, "</a></span>");
} else {
ce0 = zend_fetch_class(SL("ReflectionClass"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_INIT_VAR(class_reflection);
object_init_ex(class_reflection, ce0);
if (phalcon_has_constructor(class_reflection TSRMLS_CC)) {
phalcon_call_method_p1_noret(class_reflection, "__construct", class_name);
}
/**
* Check if classes are PHP's classes
*/
PHALCON_INIT_VAR(is_internal);
phalcon_call_method(is_internal, class_reflection, "isinternal");
if (zend_is_true(is_internal)) {
PHALCON_INIT_VAR(lower_class_name);
phalcon_fast_strtolower(lower_class_name, class_name);
PHALCON_INIT_VAR(prepare_internal_class);
phalcon_fast_str_replace(prepare_internal_class, underscore, minus, lower_class_name);
/**
* Generate a link to the official docs
*/
PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-class\"><a target=\"_new\" href=\"http://php.net/manual/en/class.", prepare_internal_class, ".php\">", class_name, "</a></span>");
} else {
PHALCON_SCONCAT_SVS(html, "<span class=\"error-class\">", class_name, "</span>");
}
}
/**
* Object access operator: static/instance
*/
PHALCON_OBS_VAR(type);
phalcon_array_fetch_string(&type, trace, SL("type"), PH_NOISY);
phalcon_concat_self(&html, type TSRMLS_CC);
}
/**
* Normally the backtrace contains only classes
*/
if (phalcon_array_isset_string(trace, SS("class"))) {
PHALCON_OBS_VAR(function_name);
phalcon_array_fetch_string(&function_name, trace, SL("function"), PH_NOISY);
PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>");
} else {
PHALCON_OBS_NVAR(function_name);
phalcon_array_fetch_string(&function_name, trace, SL("function"), PH_NOISY);
/**
* Check if the function exists
*/
if (phalcon_function_exists(function_name TSRMLS_CC) == SUCCESS) {
ce1 = zend_fetch_class(SL("ReflectionFunction"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_INIT_VAR(function_reflection);
object_init_ex(function_reflection, ce1);
if (phalcon_has_constructor(function_reflection TSRMLS_CC)) {
phalcon_call_method_p1_noret(function_reflection, "__construct", function_name);
}
PHALCON_INIT_NVAR(is_internal);
phalcon_call_method(is_internal, function_reflection, "isinternal");
/**
* Internal functions links to the PHP documentation
*/
if (zend_is_true(is_internal)) {
/**
* Prepare function's name according to the conventions in the docs
*/
PHALCON_INIT_VAR(prepared_function_name);
phalcon_fast_str_replace(prepared_function_name, underscore, minus, function_name);
PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-function\"><a target=\"_new\" href=\"http://php.net/manual/en/function.", prepared_function_name, ".php\">", function_name, "</a></span>");
} else {
PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>");
}
} else {
PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>");
}
}
/**
* Check for arguments in the function
*/
if (phalcon_array_isset_string(trace, SS("args"))) {
PHALCON_OBS_VAR(trace_args);
phalcon_array_fetch_string(&trace_args, trace, SL("args"), PH_NOISY);
if (phalcon_fast_count_ev(trace_args TSRMLS_CC)) {
PHALCON_INIT_VAR(arguments);
array_init(arguments);
phalcon_is_iterable(trace_args, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(argument);
/**
* Every argument is generated using _getVarDump
*/
PHALCON_INIT_NVAR(dumped_argument);
phalcon_call_method_p1(dumped_argument, this_ptr, "_getvardump", argument);
PHALCON_INIT_NVAR(span_argument);
PHALCON_CONCAT_SVS(span_argument, "<span class=\"error-parameter\">", dumped_argument, "</span>");
/**
* Append the HTML generated to the argument's list
*/
phalcon_array_append(&arguments, span_argument, PH_SEPARATE);
zend_hash_move_forward_ex(ah0, &hp0);
}
/**
* Join all the arguments
*/
PHALCON_INIT_VAR(joined_arguments);
phalcon_fast_join_str(joined_arguments, SL(", "), arguments TSRMLS_CC);
PHALCON_SCONCAT_SVS(html, "(", joined_arguments, ")");
} else {
phalcon_concat_self_str(&html, SL("()") TSRMLS_CC);
}
}
/**
* When 'file' is present, it usually means the function is provided by the user
*/
if (phalcon_array_isset_string(trace, SS("file"))) {
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_OBS_VAR(file);
phalcon_array_fetch_string(&file, trace, SL("file"), PH_NOISY);
PHALCON_OBS_VAR(line);
phalcon_array_fetch_string(&line, trace, SL("line"), PH_NOISY);
/**
* Realpath to the file and its line using a special header
*/
PHALCON_SCONCAT_SVSVS(html, "<br/><div class=\"error-file\">", file, " (", line, ")</div>");
PHALCON_OBS_VAR(show_files);
phalcon_read_property_this(&show_files, this_ptr, SL("_showFiles"), PH_NOISY_CC);
/**
* The developer can change if the files must be opened or not
*/
if (zend_is_true(show_files)) {
/**
* Open the file to an array using 'file', this respects the openbase-dir directive
*/
PHALCON_INIT_VAR(lines);
phalcon_call_func_p1(lines, "file", file);
PHALCON_INIT_VAR(number_lines);
phalcon_fast_count(number_lines, lines TSRMLS_CC);
PHALCON_OBS_VAR(show_file_fragment);
phalcon_read_property_this(&show_file_fragment, this_ptr, SL("_showFileFragment"), PH_NOISY_CC);
/**
* File fragments just show a piece of the file where the exception is located
*/
if (zend_is_true(show_file_fragment)) {
/**
* Take seven lines back to the current exception's line, @TODO add an option for
* this
*/
PHALCON_INIT_VAR(seven);
ZVAL_LONG(seven, 7);
PHALCON_INIT_VAR(before_line);
sub_function(before_line, line, seven TSRMLS_CC);
/**
* Check for overflows
*/
if (PHALCON_LT_LONG(before_line, 1)) {
PHALCON_CPY_WRT(first_line, one);
} else {
PHALCON_CPY_WRT(first_line, before_line);
}
/**
* Take five lines after the current exception's line, @TODO add an option for this
*/
PHALCON_INIT_VAR(five);
ZVAL_LONG(five, 5);
PHALCON_INIT_VAR(after_line);
phalcon_add_function(after_line, line, five TSRMLS_CC);
/**
* Check for overflows
*/
if (PHALCON_GT(after_line, number_lines)) {
PHALCON_CPY_WRT(last_line, number_lines);
} else {
PHALCON_CPY_WRT(last_line, after_line);
}
PHALCON_SCONCAT_SVSVSVS(html, "<pre class='prettyprint highlight:", first_line, ":", line, " linenums:", first_line, "'>");
} else {
PHALCON_CPY_WRT(first_line, one);
PHALCON_CPY_WRT(last_line, number_lines);
PHALCON_SCONCAT_SVSVS(html, "<pre class='prettyprint highlight:", first_line, ":", line, " linenums error-scroll'>");
}
PHALCON_INIT_VAR(comment_pattern);
ZVAL_STRING(comment_pattern, "#\\*\\/$#", 1);
/**
* We assume the file is utf-8 encoded, @TODO add an option for this
*/
PHALCON_INIT_VAR(utf8);
ZVAL_STRING(utf8, "UTF-8", 1);
/**
* Don't escape quotes
*/
PHALCON_INIT_VAR(ent_compat);
ZVAL_LONG(ent_compat, 2);
PHALCON_INIT_VAR(tab);
ZVAL_STRING(tab, "\t", 1);
PHALCON_INIT_VAR(comment);
ZVAL_STRING(comment, "* /", 1);
PHALCON_CPY_WRT(i, first_line);
while (1) {
if (PHALCON_LE(i, last_line)) {
} else {
break;
}
/**
* Current line in the file
*/
PHALCON_INIT_NVAR(line_position);
sub_function(line_position, i, one TSRMLS_CC);
/**
* Current line content in the piece of file
*/
PHALCON_OBS_NVAR(current_line);
phalcon_array_fetch(¤t_line, lines, line_position, PH_NOISY);
/**
* File fragments are cleaned, removing tabs and comments
*/
if (zend_is_true(show_file_fragment)) {
if (PHALCON_IS_EQUAL(i, first_line)) {
PHALCON_INIT_NVAR(trimmed);
phalcon_fast_trim(trimmed, current_line, PHALCON_TRIM_RIGHT TSRMLS_CC);
PHALCON_INIT_NVAR(is_comment);
phalcon_preg_match(is_comment, comment_pattern, current_line, NULL TSRMLS_CC);
if (zend_is_true(is_comment)) {
PHALCON_INIT_NVAR(spaced_current_line);
phalcon_fast_str_replace(spaced_current_line, comment, space, current_line);
PHALCON_CPY_WRT(current_line, spaced_current_line);
}
}
}
/**
* Print a non break space if the current line is a line break, this allows to show
* the html zebra properly
*/
if (PHALCON_IS_STRING(current_line, "\n")) {
phalcon_concat_self_str(&html, SL(" \n") TSRMLS_CC);
} else {
if (PHALCON_IS_STRING(current_line, "\r\n")) {
phalcon_concat_self_str(&html, SL(" \n") TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(spaced_current_line);
phalcon_fast_str_replace(spaced_current_line, tab, two_spaces, current_line);
PHALCON_INIT_NVAR(escaped_line);
phalcon_call_func_p3(escaped_line, "htmlentities", spaced_current_line, ent_compat, utf8);
phalcon_concat_self(&html, escaped_line TSRMLS_CC);
}
}
PHALCON_SEPARATE(i);
phalcon_increment(i);
}
phalcon_concat_self_str(&html, SL("</pre>") TSRMLS_CC);
}
}
phalcon_concat_self_str(&html, SL("</td></tr>") TSRMLS_CC);
RETURN_CTOR(html);
}
/**
* Executes the validation
*
* @param Phalcon\Validation $validator
* @param string $attribute
* @return boolean
*/
PHP_METHOD(Phalcon_Validation_Validator_Regex, validate){
zval *validator, *attribute, *value = NULL, *allow_empty, *pattern, *valid = NULL, *label, *pairs;
zval *message_str, *code, *prepared = NULL, *message;
zend_class_entry *ce = Z_OBJCE_P(getThis());
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &validator, &attribute);
PHALCON_VERIFY_CLASS_EX(validator, phalcon_validation_ce, phalcon_validation_exception_ce, 1);
PHALCON_CALL_METHOD(&value, validator, "getvalue", attribute);
PHALCON_OBS_VAR(allow_empty);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &allow_empty, getThis(), phalcon_interned_allowEmpty TSRMLS_CC));
if (zend_is_true(allow_empty) && phalcon_validation_validator_isempty_helper(value)) {
RETURN_MM_TRUE;
}
/* The regular expression is set in the option 'pattern' */
PHALCON_OBS_VAR(pattern);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &pattern, getThis(), "pattern" TSRMLS_CC));
PHALCON_CALL_SELF(&valid, "valid", value, pattern);
if (PHALCON_IS_FALSE(valid)) {
PHALCON_OBS_VAR(label);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &label, getThis(), phalcon_interned_label TSRMLS_CC));
if (!zend_is_true(label)) {
PHALCON_CALL_METHOD(&label, validator, "getlabel", attribute);
if (!zend_is_true(label)) {
PHALCON_CPY_WRT(label, attribute);
}
}
PHALCON_ALLOC_GHOST_ZVAL(pairs);
array_init_size(pairs, 1);
Z_ADDREF_P(label); add_assoc_zval_ex(pairs, SS(":field"), label);
PHALCON_OBS_VAR(message_str);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &message_str, getThis(), phalcon_interned_message TSRMLS_CC));
if (!zend_is_true(message_str)) {
PHALCON_OBSERVE_OR_NULLIFY_VAR(message_str);
RETURN_MM_ON_FAILURE(phalcon_validation_getdefaultmessage_helper(Z_OBJCE_P(validator), &message_str, validator, "Regex" TSRMLS_CC));
}
PHALCON_OBS_VAR(code);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &code, getThis(), phalcon_interned_code TSRMLS_CC));
if (Z_TYPE_P(code) == IS_NULL) {
ZVAL_LONG(code, 0);
}
PHALCON_CALL_FUNCTION(&prepared, "strtr", message_str, pairs);
message = phalcon_validation_message_construct_helper(prepared, attribute, "Regex", code TSRMLS_CC);
Z_DELREF_P(message);
PHALCON_CALL_METHOD(NULL, validator, "appendmessage", message);
RETURN_MM_FALSE;
}
RETURN_MM_TRUE;
}
/**
* Handles uncaught exceptions
*
* @param \Exception $exception
* @return boolean
*/
PHP_METHOD(Phalcon_Debug, onUncaughtException){
zval *exception, *is_active = NULL, *message = NULL;
zval *class_name, *css_sources, *escaped_message = NULL;
zval *html, *version, *file, *line, *show_back_trace;
zval *data_vars, *trace, *trace_item = NULL, *n = NULL, *html_item = NULL;
zval *_REQUEST, *value = NULL, *key_request = NULL, *_SERVER;
zval *key_server = NULL, *files, *key_file = NULL;
zval *memory, *data_var = NULL, *key_var = NULL, *variable = NULL, *dumped_argument = NULL;
zval *js_sources;
HashTable *ah0, *ah1, *ah2, *ah3, *ah4;
HashPosition hp0, hp1, hp2, hp3, hp4;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &exception);
/**
* Cancel the output buffer if active
*/
if (phalcon_ob_get_level(TSRMLS_C) > 0) {
phalcon_ob_end_clean(TSRMLS_C);
}
PHALCON_OBS_VAR(is_active);
phalcon_read_static_property(&is_active, SL("phalcon\\debug"), SL("_isActive") TSRMLS_CC);
/**
* Avoid that multiple exceptions being showed
*/
if (zend_is_true(is_active)) {
PHALCON_INIT_VAR(message);
phalcon_call_method(message, exception, "getmessage");
zend_print_zval(message, 0);
}
PHALCON_INIT_NVAR(is_active);
ZVAL_BOOL(is_active, 1);
/**
* Globally block the debug component to avoid other exceptions must be shown
*/
phalcon_update_static_property(SL("phalcon\\debug"), SL("_isActive"), is_active TSRMLS_CC);
PHALCON_INIT_VAR(class_name);
phalcon_get_class(class_name, exception, 0 TSRMLS_CC);
PHALCON_INIT_NVAR(message);
phalcon_call_method(message, exception, "getmessage");
/**
* CSS static sources to style the error presentation
*/
PHALCON_INIT_VAR(css_sources);
phalcon_call_method(css_sources, this_ptr, "getcsssources");
/**
* Escape the exception's message avoiding possible XSS injections?
*/
PHALCON_CPY_WRT(escaped_message, message);
/**
* Use the exception info as document's title
*/
PHALCON_INIT_VAR(html);
PHALCON_CONCAT_SVSVS(html, "<html><head><title>", class_name, ": ", escaped_message, "</title>");
PHALCON_SCONCAT_VS(html, css_sources, "</head><body>");
/**
* Get the version link
*/
PHALCON_INIT_VAR(version);
phalcon_call_method(version, this_ptr, "getversion");
phalcon_concat_self(&html, version TSRMLS_CC);
PHALCON_INIT_VAR(file);
phalcon_call_method(file, exception, "getfile");
PHALCON_INIT_VAR(line);
phalcon_call_method(line, exception, "getline");
/**
* Main exception info
*/
phalcon_concat_self_str(&html, SL("<div align=\"center\"><div class=\"error-main\">") TSRMLS_CC);
PHALCON_SCONCAT_SVSVS(html, "<h1>", class_name, ": ", escaped_message, "</h1>");
PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-file\">", file, " (", line, ")</span>");
phalcon_concat_self_str(&html, SL("</div>") TSRMLS_CC);
PHALCON_OBS_VAR(show_back_trace);
phalcon_read_property_this(&show_back_trace, this_ptr, SL("_showBackTrace"), PH_NOISY_CC);
/**
* Check if the developer wants to show the backtrace or not
*/
if (zend_is_true(show_back_trace)) {
PHALCON_OBS_VAR(data_vars);
phalcon_read_property_this(&data_vars, this_ptr, SL("_data"), PH_NOISY_CC);
/**
* Create the tabs in the page
*/
phalcon_concat_self_str(&html, SL("<div class=\"error-info\"><div id=\"tabs\"><ul>") TSRMLS_CC);
phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-1\">Backtrace</a></li>") TSRMLS_CC);
phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-2\">Request</a></li>") TSRMLS_CC);
phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-3\">Server</a></li>") TSRMLS_CC);
phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-4\">Included Files</a></li>") TSRMLS_CC);
phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-5\">Memory</a></li>") TSRMLS_CC);
if (Z_TYPE_P(data_vars) == IS_ARRAY) {
phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-6\">Variables</a></li>") TSRMLS_CC);
}
phalcon_concat_self_str(&html, SL("</ul>") TSRMLS_CC);
/**
* Print backtrace
*/
phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-1\"><table cellspacing=\"0\" align=\"center\" width=\"100%\">") TSRMLS_CC);
PHALCON_INIT_VAR(trace);
phalcon_call_method(trace, exception, "gettrace");
phalcon_is_iterable(trace, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(n, ah0, hp0);
PHALCON_GET_HVALUE(trace_item);
/**
* Every line in the trace is rendered using 'showTraceItem'
*/
PHALCON_INIT_NVAR(html_item);
phalcon_call_method_p2(html_item, this_ptr, "showtraceitem", n, trace_item);
phalcon_concat_self(&html, html_item TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
}
phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
/**
* Print _REQUEST superglobal
*/
phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-2\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC);
phalcon_concat_self_str(&html, SL("<tr><th>Key</th><th>Value</th></tr>") TSRMLS_CC);
phalcon_get_global(&_REQUEST, SS("_REQUEST") TSRMLS_CC);
phalcon_is_iterable(_REQUEST, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HKEY(key_request, ah1, hp1);
PHALCON_GET_HVALUE(value);
PHALCON_SCONCAT_SVSVS(html, "<tr><td class=\"key\">", key_request, "</td><td>", value, "</td></tr>");
zend_hash_move_forward_ex(ah1, &hp1);
}
phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
/**
* Print _SERVER superglobal
*/
phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-3\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC);
phalcon_concat_self_str(&html, SL("<tr><th>Key</th><th>Value</th></tr>") TSRMLS_CC);
phalcon_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC);
phalcon_is_iterable(_SERVER, &ah2, &hp2, 0, 0);
while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) {
PHALCON_GET_HKEY(key_server, ah2, hp2);
PHALCON_GET_HVALUE(value);
PHALCON_SCONCAT_SVSVS(html, "<tr><td class=\"key\">", key_server, "</td><td>", value, "</td></tr>");
zend_hash_move_forward_ex(ah2, &hp2);
}
phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
/**
* Show included files
*/
PHALCON_INIT_VAR(files);
phalcon_call_func(files, "get_included_files");
phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-4\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC);
phalcon_concat_self_str(&html, SL("<tr><th>#</th><th>Path</th></tr>") TSRMLS_CC);
phalcon_is_iterable(files, &ah3, &hp3, 0, 0);
while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) {
PHALCON_GET_HKEY(key_file, ah3, hp3);
PHALCON_GET_HVALUE(value);
PHALCON_SCONCAT_SVSVS(html, "<tr><td>", key_file, "</th><td>", value, "</td></tr>");
zend_hash_move_forward_ex(ah3, &hp3);
}
phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
/**
* Memory usage
*/
PHALCON_INIT_VAR(memory);
ZVAL_LONG(memory, zend_memory_usage(1 TSRMLS_CC));
phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-5\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC);
PHALCON_SCONCAT_SVS(html, "<tr><th colspan=\"2\">Memory</th></tr><tr><td>Usage</td><td>", memory, "</td></tr>");
phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
/**
* Print extra variables passed to the component
*/
if (Z_TYPE_P(data_vars) == IS_ARRAY) {
phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-6\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC);
phalcon_concat_self_str(&html, SL("<tr><th>Key</th><th>Value</th></tr>") TSRMLS_CC);
phalcon_is_iterable(data_vars, &ah4, &hp4, 0, 0);
while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) {
PHALCON_GET_HKEY(key_var, ah4, hp4);
PHALCON_GET_HVALUE(data_var);
PHALCON_OBS_NVAR(variable);
phalcon_array_fetch_long(&variable, data_var, 0, PH_NOISY);
PHALCON_INIT_NVAR(dumped_argument);
phalcon_call_method_p1(dumped_argument, this_ptr, "_getvardump", variable);
PHALCON_SCONCAT_SVSVS(html, "<tr><td class=\"key\">", key_var, "</td><td>", dumped_argument, "</td></tr>");
zend_hash_move_forward_ex(ah4, &hp4);
}
phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC);
}
phalcon_concat_self_str(&html, SL("</div>") TSRMLS_CC);
}
/**
* Get Javascript sources
*/
PHALCON_INIT_VAR(js_sources);
phalcon_call_method(js_sources, this_ptr, "getjssources");
PHALCON_SCONCAT_VS(html, js_sources, "</div></body></html>");
/**
* Print the HTML, @TODO, add an option to store the html
*/
zend_print_zval(html, 0);
PHALCON_INIT_NVAR(is_active);
ZVAL_BOOL(is_active, 0);
/**
* Unlock the exception renderer
*/
phalcon_update_static_property(SL("phalcon\\debug"), SL("_isActive"), is_active TSRMLS_CC);
RETURN_MM_TRUE;
}
/**
* Generates a SELECT tag
*
* @param array $parameters
* @param array $data
*/
PHP_METHOD(Phalcon_Tag_Select, selectField){
zval *parameters, *data = NULL, *params = NULL, *eol, *id = NULL, *name, *value = NULL;
zval *use_empty = NULL, *empty_value = NULL, *empty_text = NULL, *code;
zval *avalue = NULL, *key = NULL, *close_option, *options = NULL, *using;
zval *resultset_options, *array_options;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, ¶meters, &data);
if (!data) {
PHALCON_INIT_VAR(data);
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(params);
array_init_size(params, 2);
phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(¶ms, data, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_CPY_WRT(params, parameters);
}
PHALCON_INIT_VAR(eol);
ZVAL_STRING(eol, PHP_EOL, 1);
if (!phalcon_array_isset_long(params, 0)) {
PHALCON_OBS_VAR(id);
phalcon_array_fetch_string(&id, params, SL("id"), PH_NOISY_CC);
phalcon_array_update_long(¶ms, 0, &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_OBS_NVAR(id);
phalcon_array_fetch_long(&id, params, 0, PH_NOISY_CC);
if (!phalcon_array_isset_string(params, SS("name"))) {
phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_OBS_VAR(name);
phalcon_array_fetch_string(&name, params, SL("name"), PH_NOISY_CC);
if (!zend_is_true(name)) {
phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
}
/**
* Automatically assign the id if the name is not an array
*/
if (!phalcon_memnstr_str(id, SL("[") TSRMLS_CC)) {
if (!phalcon_array_isset_string(params, SS("id"))) {
phalcon_array_update_string(¶ms, SL("id"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
}
if (!phalcon_array_isset_string(params, SS("value"))) {
PHALCON_INIT_VAR(value);
PHALCON_CALL_STATIC_PARAMS_2(value, "phalcon\\tag", "getvalue", id, params);
} else {
PHALCON_OBS_NVAR(value);
phalcon_array_fetch_string(&value, params, SL("value"), PH_NOISY_CC);
phalcon_array_unset_string(¶ms, SS("value"), PH_SEPARATE);
}
PHALCON_INIT_VAR(use_empty);
ZVAL_BOOL(use_empty, 0);
if (phalcon_array_isset_string(params, SS("useEmpty"))) {
if (!phalcon_array_isset_string(params, SS("emptyValue"))) {
PHALCON_INIT_VAR(empty_value);
ZVAL_STRING(empty_value, "", 1);
} else {
PHALCON_OBS_NVAR(empty_value);
phalcon_array_fetch_string(&empty_value, params, SL("emptyValue"), PH_NOISY_CC);
phalcon_array_unset_string(¶ms, SS("emptyValue"), PH_SEPARATE);
}
if (!phalcon_array_isset_string(params, SS("emptyText"))) {
PHALCON_INIT_VAR(empty_text);
ZVAL_STRING(empty_text, "Choose...", 1);
} else {
PHALCON_OBS_NVAR(empty_text);
phalcon_array_fetch_string(&empty_text, params, SL("emptyText"), PH_NOISY_CC);
phalcon_array_unset_string(¶ms, SS("emptyText"), PH_SEPARATE);
}
PHALCON_OBS_NVAR(use_empty);
phalcon_array_fetch_string(&use_empty, params, SL("useEmpty"), PH_NOISY_CC);
phalcon_array_unset_string(¶ms, SS("useEmpty"), PH_SEPARATE);
}
PHALCON_INIT_VAR(code);
ZVAL_STRING(code, "<select", 1);
if (Z_TYPE_P(params) == IS_ARRAY) {
phalcon_is_iterable(params, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(key, ah0, hp0);
PHALCON_GET_HVALUE(avalue);
if (Z_TYPE_P(key) != IS_LONG) {
if (Z_TYPE_P(avalue) != IS_ARRAY) {
PHALCON_SCONCAT_SVSVS(code, " ", key, "=\"", avalue, "\"");
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
}
PHALCON_SCONCAT_SV(code, ">", eol);
PHALCON_INIT_VAR(close_option);
PHALCON_CONCAT_SV(close_option, "</option>", eol);
if (zend_is_true(use_empty)) {
/**
* Create an empty value
*/
PHALCON_SCONCAT_SVSVV(code, "\t<option value=\"", empty_value, "\">", empty_text, close_option);
phalcon_array_unset_string(¶ms, SS("useEmpty"), PH_SEPARATE);
}
if (phalcon_array_isset_long(params, 1)) {
PHALCON_OBS_VAR(options);
phalcon_array_fetch_long(&options, params, 1, PH_NOISY_CC);
} else {
PHALCON_CPY_WRT(options, data);
}
if (Z_TYPE_P(options) == IS_OBJECT) {
/**
* The options is a resultset
*/
if (!phalcon_array_isset_string(params, SS("using"))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "The 'using' parameter is required");
return;
} else {
PHALCON_OBS_VAR(using);
phalcon_array_fetch_string(&using, params, SL("using"), PH_NOISY_CC);
if (Z_TYPE_P(using) != IS_ARRAY) {
if (Z_TYPE_P(using) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "The 'using' parameter should be an Array");
return;
}
}
}
/**
* Create the SELECT's option from a resultset
*/
PHALCON_INIT_VAR(resultset_options);
PHALCON_CALL_SELF_PARAMS_4(resultset_options, this_ptr, "_optionsfromresultset", options, using, value, close_option);
phalcon_concat_self(&code, resultset_options TSRMLS_CC);
} else {
if (Z_TYPE_P(options) == IS_ARRAY) {
/**
* Executes the validator
*
* @param Phalcon\Mvc\ModelInterface $record
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator_Uniqueness, validate){
zval *record, *option = NULL, *field = NULL, *dependency_injector = NULL;
zval *service, *meta_data = NULL, *bind_types, *bind_data_types = NULL;
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 = NULL;
zval *primary_fields = NULL, *primary_field = NULL, *attribute_field = NULL;
zval *join_conditions, *params;
zval *message = NULL, *join_fields, *type, *is_set_code = NULL, *code = NULL;
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_CALL_METHOD(&field, this_ptr, "getoption", option);
PHALCON_CALL_METHOD(&dependency_injector, record, "getdi");
PHALCON_INIT_VAR(service);
ZVAL_STRING(service, "modelsMetadata", 1);
PHALCON_CALL_METHOD(&meta_data, dependency_injector, "getshared", service);
PHALCON_VERIFY_INTERFACE(meta_data, phalcon_mvc_model_metadatainterface_ce);
/**
* 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_CALL_METHOD(&bind_data_types, meta_data, "getbindtypes", record);
if (PHALCON_GLOBAL(orm).column_renaming) {
PHALCON_CALL_METHOD(&column_map, meta_data, "getreversecolumnmap", record);
} else {
PHALCON_INIT_VAR(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_CALL_METHOD(&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_CALL_METHOD(&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_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_CALL_METHOD(&column_map, meta_data, "getcolumnmap", record);
} else {
PHALCON_INIT_VAR(column_map);
}
PHALCON_CALL_METHOD(&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_CALL_METHOD(&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_size(params, 4);
phalcon_array_update_string(¶ms, SL("di"), dependency_injector, PH_COPY);
phalcon_array_update_string(¶ms, SL("conditions"), join_conditions, PH_COPY);
phalcon_array_update_string(¶ms, SL("bind"), bind_params, PH_COPY);
phalcon_array_update_string(¶ms, SL("bindTypes"), bind_types, PH_COPY);
/**
* Check using a standard count
*/
PHALCON_CALL_CE_STATIC(&number, Z_OBJCE_P(record), "count", params);
if (!PHALCON_IS_LONG(number, 0)) {
/**
* Check if the developer has defined a custom message
*/
PHALCON_INIT_NVAR(option);
PHALCON_ZVAL_MAYBE_INTERNED_STRING(option, phalcon_interned_message);
PHALCON_CALL_METHOD(&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);
/*
* Is code set
*/
PHALCON_INIT_NVAR(option);
PHALCON_ZVAL_MAYBE_INTERNED_STRING(option, phalcon_interned_code);
PHALCON_CALL_METHOD(&is_set_code, this_ptr, "issetoption", option);
if (zend_is_true(is_set_code)) {
PHALCON_CALL_METHOD(&code, this_ptr, "getoption", option);
} else {
PHALCON_INIT_VAR(code);
ZVAL_LONG(code, 0);
}
PHALCON_CALL_METHOD(NULL, this_ptr, "appendmessage", message, field, type, code);
RETURN_MM_FALSE;
}
RETURN_MM_TRUE;
}
/**
* 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 || 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);
PHALCON_OBS_NVAR(validator);
phalcon_array_fetch_long(&validator, scope, 1, PH_NOISY);
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);
}
/**
* Traverses a collection calling the callback to generate its HTML
*
* @param Phalcon\Assets\Collection $collection
* @param callback $callback
* @param string $type
* @param array $args
*/
PHP_METHOD(Phalcon_Assets_Manager, output){
zval *collection, *callback, *type = NULL, *args = NULL, *output, *use_implicit_output;
zval *resources = NULL, *filters = NULL, *prefix = NULL, *source_base_path = NULL;
zval *target_base_path = NULL, *options, *collection_source_path = NULL;
zval *complete_source_path = NULL, *collection_target_path = NULL;
zval *complete_target_path = NULL, *filtered_joined_content = NULL;
zval *join = NULL, *exception_message = NULL, *is_directory;
zval *resource = NULL, *filter_needed = NULL, *local = NULL, *source_path = NULL;
zval *target_path = NULL, *path = NULL, *prefixed_path = NULL, *attributes = NULL;
zval *parameters = NULL, *html = NULL, *content = NULL, *must_filter = NULL;
zval *filter = NULL, *filtered_content = NULL, *target_uri = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
zval *type_css;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 2, &collection, &callback, &type, &args);
if (!args) {
args = PHALCON_GLOBAL(z_null);
}
PHALCON_INIT_VAR(output);
PHALCON_OBS_VAR(use_implicit_output);
phalcon_read_property_this(&use_implicit_output, this_ptr, SL("_implicitOutput"), PH_NOISY TSRMLS_CC);
/**
* Get the resources as an array
*/
PHALCON_CALL_METHOD(&resources, collection, "getresources");
/**
* Get filters in the collection
*/
PHALCON_CALL_METHOD(&filters, collection, "getfilters");
/**
* Get the collection's prefix
*/
PHALCON_CALL_METHOD(&prefix, collection, "getprefix");
PHALCON_INIT_VAR(type_css);
ZVAL_STRING(type_css, "css", 1);
/**
* Prepare options if the collection must be filtered
*/
if (Z_TYPE_P(filters) == IS_ARRAY) {
PHALCON_INIT_VAR(source_base_path);
PHALCON_INIT_VAR(target_base_path);
PHALCON_OBS_VAR(options);
phalcon_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY TSRMLS_CC);
/**
* Check for global options in the assets manager
*/
if (Z_TYPE_P(options) == IS_ARRAY) {
/**
* The source base path is a global location where all resources are located
*/
if (phalcon_array_isset_string(options, SS("sourceBasePath"))) {
PHALCON_OBS_NVAR(source_base_path);
phalcon_array_fetch_string(&source_base_path, options, SL("sourceBasePath"), PH_NOISY);
}
/**
* The target base path is a global location where all resources are written
*/
if (phalcon_array_isset_string(options, SS("targetBasePath"))) {
PHALCON_OBS_NVAR(target_base_path);
phalcon_array_fetch_string(&target_base_path, options, SL("targetBasePath"), PH_NOISY);
}
}
/**
* Check if the collection have its own source base path
*/
PHALCON_CALL_METHOD(&collection_source_path, collection, "getsourcepath");
/**
* Concatenate the global base source path with the collection one
*/
if (PHALCON_IS_NOT_EMPTY(collection_source_path)) {
PHALCON_INIT_VAR(complete_source_path);
PHALCON_CONCAT_VV(complete_source_path, source_base_path, collection_source_path);
} else {
PHALCON_CPY_WRT(complete_source_path, source_base_path);
}
/**
* Check if the collection have its own target base path
*/
PHALCON_CALL_METHOD(&collection_target_path, collection, "gettargetpath");
/**
* Concatenate the global base source path with the collection one
*/
if (PHALCON_IS_NOT_EMPTY(collection_target_path)) {
PHALCON_INIT_VAR(complete_target_path);
PHALCON_CONCAT_VV(complete_target_path, target_base_path, collection_target_path);
} else {
PHALCON_CPY_WRT(complete_target_path, target_base_path);
}
/**
* Global filtered content
*/
PHALCON_INIT_VAR(filtered_joined_content);
/**
* Check if all the resources in the collection must be joined
*/
PHALCON_CALL_METHOD(&join, collection, "getjoin");
/**
* Check for valid target paths if the collection must be joined
*/
if (zend_is_true(join)) {
/**
* We need a valid final target path
*/
if (PHALCON_IS_EMPTY(complete_target_path)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Path '", complete_target_path, "' is not a valid target path (1)");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_assets_exception_ce, exception_message);
return;
}
PHALCON_INIT_VAR(is_directory);
phalcon_is_dir(is_directory, complete_target_path TSRMLS_CC);
/**
* The targetpath needs to be a valid file
*/
if (PHALCON_IS_TRUE(is_directory)) {
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Path '", complete_target_path, "' is not a valid target path (2)");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_assets_exception_ce, exception_message);
return;
}
}
}
phalcon_is_iterable(resources, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(resource);
PHALCON_INIT_NVAR(filter_needed);
ZVAL_FALSE(filter_needed);
if (!type) {
PHALCON_CALL_METHOD(&type, resource, "gettype");
}
/**
* Is the resource local?
*/
PHALCON_CALL_METHOD(&local, resource, "getlocal");
/**
* If the collection must not be joined we must print a HTML for each one
*/
if (Z_TYPE_P(filters) == IS_ARRAY) {
if (zend_is_true(local)) {
/**
* Get the complete path
*/
PHALCON_CALL_METHOD(&source_path, resource, "getrealsourcepath", complete_source_path);
/**
* We need a valid source path
*/
if (!zend_is_true(source_path)) {
PHALCON_CALL_METHOD(&source_path, resource, "getpath");
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Resource '", source_path, "' does not have a valid source path");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_assets_exception_ce, exception_message);
return;
}
} else {
/**
* Get the complete source path
*/
PHALCON_CALL_METHOD(&source_path, resource, "getpath");
/**
* resources paths are always filtered
*/
PHALCON_INIT_NVAR(filter_needed);
ZVAL_TRUE(filter_needed);
}
/**
* Get the target path, we need to write the filtered content to a file
*/
PHALCON_CALL_METHOD(&target_path, resource, "getrealtargetpath", complete_target_path);
/**
* We need a valid final target path
*/
if (PHALCON_IS_EMPTY(target_path)) {
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Resource '", source_path, "' does not have a valid target path");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_assets_exception_ce, exception_message);
return;
}
if (zend_is_true(local)) {
/**
* Make sure the target path is not the same source path
*/
if (PHALCON_IS_EQUAL(target_path, source_path)) {
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Resource '", target_path, "' have the same source and target paths");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_assets_exception_ce, exception_message);
return;
}
if (phalcon_file_exists(target_path TSRMLS_CC) == SUCCESS) {
if (phalcon_compare_mtime(target_path, source_path TSRMLS_CC)) {
PHALCON_INIT_NVAR(filter_needed);
ZVAL_TRUE(filter_needed);
}
} else {
PHALCON_INIT_NVAR(filter_needed);
ZVAL_TRUE(filter_needed);
}
}
}
/**
* If there are no filters, just print/buffer the HTML
*/
if (Z_TYPE_P(filters) != IS_ARRAY) {
PHALCON_CALL_METHOD(&path, resource, "getrealtargeturi");
if (Z_TYPE_P(prefix) != IS_NULL) {
PHALCON_INIT_NVAR(prefixed_path);
PHALCON_CONCAT_VV(prefixed_path, prefix, path);
} else {
PHALCON_CPY_WRT(prefixed_path, path);
}
/**
* Gets extra HTML attributes in the resource
*/
PHALCON_CALL_METHOD(&attributes, resource, "getattributes");
/**
* Prepare the parameters for the callback
*/
PHALCON_INIT_NVAR(parameters);
array_init_size(parameters, 3);
if (Z_TYPE_P(attributes) == IS_ARRAY) {
phalcon_array_update_long(&attributes, 0, prefixed_path, PH_COPY);
phalcon_array_append(¶meters, attributes, PH_COPY);
} else {
phalcon_array_append(¶meters, prefixed_path, PH_COPY);
}
phalcon_array_append(¶meters, local, PH_COPY);
phalcon_array_append(¶meters, args, PH_COPY);
/**
* Call the callback to generate the HTML
*/
PHALCON_INIT_NVAR(html);/**/
PHALCON_CALL_USER_FUNC_ARRAY(html, callback, parameters);
/**
* Implicit output prints the content directly
*/
if (zend_is_true(use_implicit_output)) {
zend_print_zval(html, 0);
} else {
phalcon_concat_self(&output, html TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
if (zend_is_true(filter_needed)) {
/**
* Get the resource's content
*/
PHALCON_CALL_METHOD(&content, resource, "getcontent", complete_source_path);
/**
* Check if the resource must be filtered
*/
PHALCON_CALL_METHOD(&must_filter, resource, "getfilter");
/**
* Only filter the resource if it's marked as 'filterable'
*/
if (zend_is_true(must_filter)) {
phalcon_is_iterable(filters, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HVALUE(filter);
/**
* Filters must be valid objects
*/
if (Z_TYPE_P(filter) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_assets_exception_ce, "Filter is invalid");
return;
}
/**
* Calls the method 'filter' which must return a filtered version of the content
*/
PHALCON_CALL_METHOD(&filtered_content, filter, "filter", content);
PHALCON_CPY_WRT_CTOR(content, filtered_content);
zend_hash_move_forward_ex(ah1, &hp1);
}
/**
* Update the joined filtered content
*/
if (zend_is_true(join)) {
if (PHALCON_IS_EQUAL(type, type_css)) {
if (Z_TYPE_P(filtered_joined_content) == IS_NULL) {
PHALCON_INIT_NVAR(filtered_joined_content);
PHALCON_CONCAT_VS(filtered_joined_content, content, "");
} else {
PHALCON_SCONCAT_VS(filtered_joined_content, content, "");
}
} else {
if (Z_TYPE_P(filtered_joined_content) == IS_NULL) {
PHALCON_INIT_NVAR(filtered_joined_content);
PHALCON_CONCAT_VS(filtered_joined_content, content, ";");
} else {
PHALCON_SCONCAT_VS(filtered_joined_content, content, ";");
}
}
}
} else {
/**
* Update the joined filtered content
*/
if (zend_is_true(join)) {
if (Z_TYPE_P(filtered_joined_content) == IS_NULL) {
PHALCON_CPY_WRT(filtered_joined_content, content);
} else {
phalcon_concat_self(&filtered_joined_content, content TSRMLS_CC);
}
} else {
PHALCON_CPY_WRT(filtered_content, content);
}
}
if (!zend_is_true(join)) {
/**
* Write the file using file-put-contents. This respects the openbase-dir also
* writes to streams
*/
phalcon_file_put_contents(NULL, target_path, filtered_content TSRMLS_CC);
}
}
if (!zend_is_true(join)) {
/**
* Generate the HTML using the original path in the resource
*/
PHALCON_CALL_METHOD(&path, resource, "getrealtargeturi");
if (Z_TYPE_P(prefix) != IS_NULL) {
PHALCON_INIT_NVAR(prefixed_path);
PHALCON_CONCAT_VV(prefixed_path, prefix, path);
} else {
PHALCON_CPY_WRT(prefixed_path, path);
}
/**
* Gets extra HTML attributes in the resource
*/
PHALCON_CALL_METHOD(&attributes, resource, "getattributes");
/**
* Filtered resources are always local
*/
PHALCON_INIT_NVAR(local);
ZVAL_TRUE(local);
/**
* Prepare the parameters for the callback
*/
PHALCON_INIT_NVAR(parameters);
array_init_size(parameters, 3);
if (Z_TYPE_P(attributes) == IS_ARRAY) {
phalcon_array_update_long(&attributes, 0, prefixed_path, PH_COPY);
phalcon_array_append(¶meters, attributes, PH_COPY);
} else {
phalcon_array_append(¶meters, prefixed_path, PH_COPY);
}
phalcon_array_append(¶meters, local, PH_COPY);
phalcon_array_append(¶meters, args, PH_COPY);
/**
* Call the callback to generate the HTML
*/
PHALCON_INIT_NVAR(html);/**/
PHALCON_CALL_USER_FUNC_ARRAY(html, callback, parameters);
/**
* Implicit output prints the content directly
*/
if (zend_is_true(use_implicit_output)) {
zend_print_zval(html, 0);
} else {
phalcon_concat_self(&output, html TSRMLS_CC);
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
if (Z_TYPE_P(filters) == IS_ARRAY) {
if (zend_is_true(join)) {
/**
* Write the file using file_put_contents. This respects the openbase-dir also
* writes to streams
*/
phalcon_file_put_contents(NULL, complete_target_path, filtered_joined_content TSRMLS_CC);
/**
* Generate the HTML using the original path in the resource
*/
PHALCON_CALL_METHOD(&target_uri, collection, "gettargeturi");
if (Z_TYPE_P(prefix) != IS_NULL) {
PHALCON_INIT_NVAR(prefixed_path);
PHALCON_CONCAT_VV(prefixed_path, prefix, target_uri);
} else {
PHALCON_CPY_WRT(prefixed_path, target_uri);
}
/**
* Gets extra HTML attributes in the resource
*/
PHALCON_CALL_METHOD(&attributes, collection, "getattributes");
PHALCON_CALL_METHOD(&local, collection, "gettargetlocal");
/**
* Prepare the parameters for the callback
*/
PHALCON_INIT_NVAR(parameters);
array_init_size(parameters, 3);
if (Z_TYPE_P(attributes) == IS_ARRAY) {
phalcon_array_update_long(&attributes, 0, prefixed_path, PH_COPY);
phalcon_array_append(¶meters, attributes, PH_COPY);
} else {
phalcon_array_append(¶meters, prefixed_path, PH_COPY);
}
phalcon_array_append(¶meters, local, PH_COPY);
phalcon_array_append(¶meters, args, PH_COPY);
/**
* Call the callback to generate the HTML
*/
PHALCON_INIT_NVAR(html);/**/
PHALCON_CALL_USER_FUNC_ARRAY(html, callback, parameters);
/**
* Implicit output prints the content directly
*/
if (zend_is_true(use_implicit_output)) {
zend_print_zval(html, 0);
} else {
phalcon_concat_self(&output, html TSRMLS_CC);
}
}
}
RETURN_CCTOR(output);
}
/**
* Returns an array of Phalcon\Db\Column objects describing a table
*
* <code>print_r($connection->describeColumns("posts")); ?></code>
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Column[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Oracle, describeColumns){
zval *table, *schema = NULL, *columns, *dialect, *sql, *fetch_num;
zval *describe, *old_column = NULL, *field = NULL, *definition = NULL;
zval *column_size = NULL, *column_precision = NULL, *column_scale = NULL;
zval *column_type = NULL, *attribute = NULL, *column_name = NULL;
zval *column = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &table, &schema);
if (!schema) {
PHALCON_INIT_VAR(schema);
}
PHALCON_INIT_VAR(columns);
array_init(columns);
PHALCON_OBS_VAR(dialect);
phalcon_read_property_this(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC);
PHALCON_INIT_VAR(sql);
phalcon_call_method_p2(sql, dialect, "describecolumns", table, schema);
/**
* We're using FETCH_NUM to fetch the columns
*/
PHALCON_INIT_VAR(fetch_num);
ZVAL_LONG(fetch_num, 3);
PHALCON_INIT_VAR(describe);
phalcon_call_method_p2(describe, this_ptr, "fetchall", sql, fetch_num);
/**
* 0:column_name, 1:data_type, 2:data_length, 3:data_precision, 4:data_scale,
* 5:nullable, 6:constraint_type, 7:default, 8:position;
*/
PHALCON_INIT_VAR(old_column);
phalcon_is_iterable(describe, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(field);
PHALCON_INIT_NVAR(definition);
array_init_size(definition, 1);
add_assoc_long_ex(definition, SS("bindType"), 2);
PHALCON_OBS_NVAR(column_size);
phalcon_array_fetch_long(&column_size, field, 2, PH_NOISY);
PHALCON_OBS_NVAR(column_precision);
phalcon_array_fetch_long(&column_precision, field, 3, PH_NOISY);
PHALCON_OBS_NVAR(column_scale);
phalcon_array_fetch_long(&column_scale, field, 4, PH_NOISY);
PHALCON_OBS_NVAR(column_type);
phalcon_array_fetch_long(&column_type, field, 1, PH_NOISY);
/**
* Check the column type to get the correct Phalcon type
*/
while (1) {
/**
* Integer
*/
if (phalcon_memnstr_str(column_type, SL("NUMBER"))) {
phalcon_array_update_string_long(&definition, SL("type"), 3, PH_SEPARATE);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE);
phalcon_array_update_string(&definition, SL("size"), &column_precision, PH_COPY | PH_SEPARATE);
phalcon_array_update_string(&definition, SL("scale"), &column_scale, PH_COPY | PH_SEPARATE);
phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_SEPARATE);
break;
}
/**
* Tinyint(1) is boolean
*/
if (phalcon_memnstr_str(column_type, SL("TINYINT(1)"))) {
phalcon_array_update_string_long(&definition, SL("type"), 8, PH_SEPARATE);
phalcon_array_update_string_long(&definition, SL("bindType"), 5, PH_SEPARATE);
break;
}
/**
* Smallint/Bigint/Integers/Int are int
*/
if (phalcon_memnstr_str(column_type, SL("INTEGER"))) {
phalcon_array_update_string_long(&definition, SL("type"), 0, PH_SEPARATE);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE);
phalcon_array_update_string(&definition, SL("size"), &column_precision, PH_COPY | PH_SEPARATE);
phalcon_array_update_string_long(&definition, SL("bindType"), 1, PH_SEPARATE);
break;
}
/**
* Float/Smallfloats/Decimals are float
*/
if (phalcon_memnstr_str(column_type, SL("FLOAT"))) {
phalcon_array_update_string_long(&definition, SL("type"), 7, PH_SEPARATE);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE);
phalcon_array_update_string(&definition, SL("size"), &column_size, PH_COPY | PH_SEPARATE);
phalcon_array_update_string(&definition, SL("scale"), &column_scale, PH_COPY | PH_SEPARATE);
phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_SEPARATE);
break;
}
/**
* Date
*/
if (phalcon_memnstr_str(column_type, SL("TIMESTAMP"))) {
phalcon_array_update_string_long(&definition, SL("type"), 1, PH_SEPARATE);
break;
}
/**
* Text
*/
if (phalcon_memnstr_str(column_type, SL("RAW"))) {
phalcon_array_update_string_long(&definition, SL("type"), 6, PH_SEPARATE);
break;
}
/**
* Text
*/
if (phalcon_memnstr_str(column_type, SL("BLOB"))) {
phalcon_array_update_string_long(&definition, SL("type"), 6, PH_SEPARATE);
break;
}
/**
* Text
*/
if (phalcon_memnstr_str(column_type, SL("CLOB"))) {
phalcon_array_update_string_long(&definition, SL("type"), 6, PH_SEPARATE);
break;
}
/**
* Chars2 are string
*/
if (phalcon_memnstr_str(column_type, SL("VARCHAR2"))) {
phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE);
phalcon_array_update_string(&definition, SL("size"), &column_size, PH_COPY | PH_SEPARATE);
break;
}
/**
* Chars are chars
*/
if (phalcon_memnstr_str(column_type, SL("CHAR"))) {
phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE);
phalcon_array_update_string(&definition, SL("size"), &column_size, PH_COPY | PH_SEPARATE);
break;
}
/**
* Text are varchars
*/
if (phalcon_memnstr_str(column_type, SL("text"))) {
phalcon_array_update_string_long(&definition, SL("type"), 6, PH_SEPARATE);
break;
}
/**
* By default is string
*/
phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE);
break;
}
if (Z_TYPE_P(old_column) == IS_NULL) {
phalcon_array_update_string_bool(&definition, SL("first"), 1, PH_SEPARATE);
} else {
phalcon_array_update_string(&definition, SL("after"), &old_column, PH_COPY | PH_SEPARATE);
}
/**
* Check if the field is primary key
*/
PHALCON_OBS_NVAR(attribute);
phalcon_array_fetch_long(&attribute, field, 6, PH_NOISY);
if (PHALCON_IS_STRING(attribute, "P")) {
phalcon_array_update_string_bool(&definition, SL("primary"), 1, PH_SEPARATE);
}
/**
* Check if the column allows null values
*/
PHALCON_OBS_NVAR(attribute);
phalcon_array_fetch_long(&attribute, field, 5, PH_NOISY);
if (PHALCON_IS_STRING(attribute, "N")) {
phalcon_array_update_string_bool(&definition, SL("notNull"), 1, PH_SEPARATE);
}
PHALCON_OBS_NVAR(column_name);
phalcon_array_fetch_long(&column_name, field, 0, PH_NOISY);
/**
* Create a Phalcon\Db\Column to abstract the column
*/
PHALCON_INIT_NVAR(column);
object_init_ex(column, phalcon_db_column_ce);
phalcon_call_method_p2_noret(column, "__construct", column_name, definition);
phalcon_array_append(&columns, column, PH_SEPARATE);
PHALCON_CPY_WRT(old_column, column_name);
zend_hash_move_forward_ex(ah0, &hp0);
}
RETURN_CTOR(columns);
}
/**
* Returns human readable sizes
*
* @param int $size
* @param string $forceUnit
* @param string $format
* @param boolean $si
* @return string
*/
PHP_METHOD(Phalcon_Text, bytes){
zval *z_size, *z_force_unit = NULL, *format = NULL, *si = NULL;
char *force_unit;
const char **units;
const char *units1[] = {"B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"};
const char *units2[] = {"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"};
double size;
int mod, power = 0, found = 0, i, j = 0;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 3, &z_size, &z_force_unit, &format, &si);
PHALCON_SEPARATE_PARAM(z_size);
convert_to_double(z_size);
size = Z_DVAL_P(z_size);
if (!z_force_unit) {
PHALCON_INIT_VAR(z_force_unit);
} else {
PHALCON_SEPARATE_PARAM(z_force_unit);
convert_to_string(z_force_unit);
}
if (!format) {
PHALCON_INIT_VAR(format);
} else {
PHALCON_SEPARATE_PARAM(format);
convert_to_string(format);
}
if (PHALCON_IS_EMPTY(format)) {
PHALCON_INIT_NVAR(format);
ZVAL_STRING(format, "%01.2f %s", 1);
}
if (!si) {
si = PHALCON_GLOBAL(z_true);
}
if (!zend_is_true(si) || (!PHALCON_IS_EMPTY(z_force_unit) && phalcon_memnstr_str(z_force_unit, SL("i")))) {
units = units2;
mod = 1024;
} else {
units = units1;
mod = 1000;
}
if (!PHALCON_IS_EMPTY(z_force_unit)) {
force_unit = Z_STRVAL_P(z_force_unit);
for (i = 0; i < sizeof(units); i++)
{
if (strcasecmp(force_unit, units[i]) == 0) {
found = 1;
power = i;
break;
}
}
}
if (found) {
while(j < power) {
size /= mod;
j++;
}
} else {
while(size > mod) {
size /= mod;
power++;
}
}
PHALCON_INIT_NVAR(z_size);
ZVAL_DOUBLE(z_size, size);
PHALCON_INIT_NVAR(z_force_unit);
ZVAL_STRING(z_force_unit, units[power], 1);
PHALCON_RETURN_CALL_FUNCTION("sprintf", format, z_size, z_force_unit);
RETURN_MM();
}
/**
* 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_CC);
}
/**
* 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_CC);
} 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_CC);
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_CC);
} 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_CC);
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_CC);
} 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_CC);
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 validation
*
* @param string $file
* @param int $minsize
* @param int $maxsize
* @param array $mimes
* @param int $minwidth
* @param int $maxwidth
* @param int $minheight
* @param int $maxheight
* @return boolean
*/
PHP_METHOD(Phalcon_Validation_Validator_File, valid)
{
zval *value, *minsize = NULL, *maxsize = NULL, *mimes = NULL, *minwidth = NULL, *maxwidth = NULL, *minheight = NULL, *maxheight = NULL;
zval file = {}, size = {}, *constant, finfo = {}, pathname = {}, mime = {}, image = {}, imageinfo = {}, width = {}, height = {}, valid = {};
zend_class_entry *imagick_ce;
phalcon_fetch_params(0, 1, 7, &value, &minsize, &maxsize, &mimes, &minwidth, &maxwidth, &minheight, &maxheight);
if (Z_TYPE_P(value) == IS_STRING) {
object_init_ex(&file, spl_ce_SplFileInfo);
if (phalcon_has_constructor(&file)) {
PHALCON_CALL_METHODW(NULL, &file, "__construct", value);
}
} else if (Z_TYPE_P(value) == IS_OBJECT && instanceof_function_ex(Z_OBJCE_P(value), spl_ce_SplFileInfo, 0)) {
PHALCON_CPY_WRT(&file, value);
}
if (Z_TYPE(file) <= IS_NULL) {
phalcon_update_property_str(getThis(), SL("_type"), SL("TypeUnknow"));
RETURN_FALSE;
}
if (!minsize) {
minsize = &PHALCON_GLOBAL(z_null);
}
if (!maxsize) {
maxsize = &PHALCON_GLOBAL(z_null);
}
if (!mimes) {
mimes = &PHALCON_GLOBAL(z_null);
}
if (!minwidth) {
minwidth = &PHALCON_GLOBAL(z_null);
}
if (!maxwidth) {
maxwidth = &PHALCON_GLOBAL(z_null);
}
if (!minheight) {
minheight = &PHALCON_GLOBAL(z_null);
}
if (!maxheight) {
maxheight = &PHALCON_GLOBAL(z_null);
}
PHALCON_CALL_METHODW(&valid, &file, "isfile");
if (!zend_is_true(&valid)) {
phalcon_update_property_str(getThis(), SL("_type"), SL("FileValid"));
RETURN_FALSE;
}
PHALCON_CALL_METHODW(&size, &file, "getsize");
if (!PHALCON_IS_EMPTY(minsize)) {
is_smaller_or_equal_function(&valid, minsize, &size);
if (!zend_is_true(&valid)) {
phalcon_update_property_str(getThis(), SL("_type"), SL("TooSmall"));
RETURN_FALSE;
}
}
if (!PHALCON_IS_EMPTY(maxsize)) {
is_smaller_or_equal_function(&valid, &size, maxsize);
if (!zend_is_true(&valid)) {
phalcon_update_property_str(getThis(), SL("_type"), SL("TooLarge"));
RETURN_FALSE;
}
}
PHALCON_CALL_METHODW(&pathname, &file, "getpathname");
if (Z_TYPE_P(mimes) == IS_ARRAY) {
if ((constant = zend_get_constant_str(SL("FILEINFO_MIME_TYPE"))) == NULL) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_validation_exception_ce, "Undefined constant `FILEINFO_MIME_TYPE`");
return;
}
PHALCON_CALL_FUNCTIONW(&finfo, "finfo_open", constant);
if (Z_TYPE(finfo) != IS_RESOURCE) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_validation_exception_ce, "Opening fileinfo database failed");
return;
}
PHALCON_CALL_FUNCTIONW(&mime, "finfo_file", &finfo, &pathname);
PHALCON_CALL_FUNCTIONW(NULL, "finfo_close", &finfo);
if (!phalcon_fast_in_array(&mime, mimes)) {
phalcon_update_property_str(getThis(), SL("_type"), SL("MimeValid"));
RETURN_FALSE;
}
}
if (phalcon_class_str_exists(SL("imagick"), 0) != NULL) {
imagick_ce = phalcon_fetch_str_class(SL("Imagick"), ZEND_FETCH_CLASS_AUTO);
object_init_ex(&image, imagick_ce);
PHALCON_CALL_METHODW(NULL, &image, "__construct", &pathname);
PHALCON_CALL_METHODW(&width, &image, "getImageWidth");
PHALCON_CALL_METHODW(&height, &image, "getImageHeight");
} else if (phalcon_function_exists_ex(SL("getimagesize")) != FAILURE) {
PHALCON_CALL_FUNCTIONW(&imageinfo, "getimagesize", &pathname);
if (!phalcon_array_isset_fetch_long(&width, &imageinfo, 0)) {
ZVAL_LONG(&width, -1);
}
if (!phalcon_array_isset_fetch_long(&height, &imageinfo, 1)) {
ZVAL_LONG(&height, -1);
}
} else {
ZVAL_LONG(&width, -1);
ZVAL_LONG(&height, -1);
}
if (!PHALCON_IS_EMPTY(minwidth)) {
is_smaller_or_equal_function(&valid, minwidth, &width);
if (!zend_is_true(&valid)) {
phalcon_update_property_str(getThis(), SL("_type"), SL("TooNarrow"));
RETURN_FALSE;
}
}
if (!PHALCON_IS_EMPTY(maxwidth)) {
is_smaller_or_equal_function(&valid, &width, maxwidth);
if (!zend_is_true(&valid)) {
phalcon_update_property_str(getThis(), SL("_type"), SL("TooWide"));
RETURN_FALSE;
}
}
if (!PHALCON_IS_EMPTY(minheight)) {
is_smaller_or_equal_function(&valid, minheight, &height);
if (!zend_is_true(&valid)) {
phalcon_update_property_str(getThis(), SL("_type"), SL("TooShort"));
RETURN_FALSE;
}
}
if (!PHALCON_IS_EMPTY(maxheight)) {
is_smaller_or_equal_function(&valid, &height, maxheight);
if (!zend_is_true(&valid)) {
phalcon_update_property_str(getThis(), SL("_type"), SL("TooLong"));
RETURN_FALSE;
}
}
RETURN_TRUE;
}