/**
* Deny access to a role on a resource
*
* You can use '*' as wildcard
*
* Example:
* <code>
* //Deny access to guests to search on customers
* $acl->deny('guests', 'customers', 'search');
*
* //Deny access to guests to search or create on customers
* $acl->deny('guests', 'customers', array('search', 'create'));
*
* //Deny access to any role to browse on products
* $acl->deny('*', 'products', 'browse');
*
* //Deny access to any role to browse on any resource
* $acl->deny('*', '*', 'browse');
* </code>
*
* @param string $roleName
* @param string $resourceName
* @param mixed $access
* @return boolean
*/
PHP_METHOD(Phalcon_Acl_Adapter_Memory, deny){
zval *role_name, *resource_name, *access, *action, *roles_names;
zval *key = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 3, 0, &role_name, &resource_name, &access);
PHALCON_INIT_VAR(action);
ZVAL_LONG(action, 0);
if (!PHALCON_IS_STRING(role_name, "*")) {
PHALCON_RETURN_CALL_METHOD(this_ptr, "_allowordeny", role_name, resource_name, access, action);
} else {
PHALCON_OBS_VAR(roles_names);
phalcon_read_property_this(&roles_names, this_ptr, SL("_rolesNames"), PH_NOISY TSRMLS_CC);
phalcon_is_iterable(roles_names, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(key, ah0, hp0);
PHALCON_CALL_METHOD(NULL, this_ptr, "_allowordeny", key, resource_name, access, action);
zend_hash_move_forward_ex(ah0, &hp0);
}
}
RETURN_MM();
}
/**
* Returns an HTML string of debugging information about any number of
* variables, each wrapped in a "pre" tag.
*
* <code>
* $foo = "string";
* $bar = ["key" => "value"];
* $baz = new stdClass();
* echo (new \Phalcon\Debug\Dump())->variables($foo, $bar, $baz);
*</code>
*
* @param mixed variable
* @param ...
*/
PHP_METHOD(Phalcon_Debug_Dump, variables){
zval *arg_list = NULL, *name = NULL, *variable = NULL, *output = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
PHALCON_CALL_FUNCTION(&arg_list, "func_get_args");
phalcon_is_iterable(arg_list, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(name, ah0, hp0);
PHALCON_GET_HVALUE(variable);
PHALCON_CALL_SELF(&output, "variable", variable);
PHALCON_SCONCAT(return_value, output);
zend_hash_move_forward_ex(ah0, &hp0);
}
RETURN_MM();
}
/**
* Returns the paths using positions as keys and names as values
*
* @return array
*/
PHP_METHOD(Phalcon_Mvc_Router_Route, getReversedPaths){
zval *reversed, *paths, *position = NULL, *path = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(reversed);
array_init(reversed);
PHALCON_OBS_VAR(paths);
phalcon_read_property_this(&paths, this_ptr, SL("_paths"), PH_NOISY_CC);
phalcon_is_iterable(paths, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(path, ah0, hp0);
PHALCON_GET_HVALUE(position);
phalcon_array_update_zval(&reversed, position, &path, PH_COPY | PH_SEPARATE);
zend_hash_move_forward_ex(ah0, &hp0);
}
RETURN_CTOR(reversed);
}
/**
* Prints the messages in the session flasher
*
* @param string $type
* @param boolean $remove
*/
PHP_METHOD(Phalcon_Flash_Session, output){
zval *remove = NULL, *messages = NULL, *message = NULL, *type = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, &remove);
if (!remove) {
remove = PHALCON_GLOBAL(z_true);
}
PHALCON_CALL_METHOD(&messages, this_ptr, "_getsessionmessages", remove);
if (Z_TYPE_P(messages) == IS_ARRAY) {
phalcon_is_iterable(messages, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(type, ah0, hp0);
PHALCON_GET_HVALUE(message);
PHALCON_CALL_METHOD(NULL, this_ptr, "outputmessage", type, message);
zend_hash_move_forward_ex(ah0, &hp0);
}
}
PHALCON_MM_RESTORE();
}
/**
* Returns the paths using positions as keys and names as values
*
* @return array
*/
PHP_METHOD(Phalcon_Mvc_Router_Route, getReversedPaths){
zval *paths, *position = NULL, *path = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(paths);
phalcon_read_property_this(&paths, this_ptr, SL("_paths"), PH_NOISY TSRMLS_CC);
phalcon_is_iterable(paths, &ah0, &hp0, 0, 0);
array_init_size(return_value, zend_hash_num_elements(ah0));
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(path, ah0, hp0);
PHALCON_GET_HVALUE(position);
phalcon_array_update_zval(&return_value, position, path, PH_COPY);
zend_hash_move_forward_ex(ah0, &hp0);
}
RETURN_MM();
}
/**
* Restore a Phalcon\Http\Response\Headers object
*
* @param array $data
* @return Phalcon\Http\Response\Headers
*/
PHP_METHOD(Phalcon_Http_Response_Headers, __set_state){
zval *data, *headers, *data_headers, *value = NULL, *key = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &data);
PHALCON_INIT_VAR(headers);
object_init_ex(headers, phalcon_http_response_headers_ce);
if (phalcon_array_isset_string(data, SS("_headers"))) {
PHALCON_OBS_VAR(data_headers);
phalcon_array_fetch_string(&data_headers, data, SL("_headers"), PH_NOISY);
phalcon_is_iterable(data_headers, &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_method_p2_noret(headers, "set", key, value);
zend_hash_move_forward_ex(ah0, &hp0);
}
}
RETURN_CTOR(headers);
}
/**
* Phalcon\Translate\Adapter\Gettext constructor
*
* @param array $options
* @throws \Phalcon\Translate\Exception
*/
PHP_METHOD(Phalcon_Translate_Adapter_Gettext, __construct){
zval *options, *locale, *default_domain, *directory, *setting, *key = NULL, *value = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &options);
if (Z_TYPE_P(options) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_translate_exception_ce, "Invalid options");
return;
}
if (!phalcon_array_isset_string_fetch(&locale, options, SS("locale"))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_translate_exception_ce, "Parameter \"locale\" is required");
return;
}
if (!phalcon_array_isset_string_fetch(&default_domain, options, SS("defaultDomain"))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_translate_exception_ce, "Parameter \"defaultDomain\" is required");
return;
}
if (!phalcon_array_isset_string_fetch(&directory, options, SS("directory"))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_translate_exception_ce, "Parameter \"directory\" is required");
return;
}
phalcon_update_property_this(this_ptr, SL("_locale"), locale TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_defaultDomain"), default_domain TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_directory"), directory TSRMLS_CC);
PHALCON_INIT_VAR(setting);
PHALCON_CONCAT_SV(setting, "LC_ALL=", locale);
PHALCON_CALL_FUNCTION(NULL, "putenv", setting);
setlocale(LC_ALL, Z_STRVAL_P(locale));
if (Z_TYPE_P(directory) == IS_ARRAY) {
phalcon_is_iterable(directory, &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);
bindtextdomain(Z_STRVAL_P(key), Z_STRVAL_P(value));
zend_hash_move_forward_ex(ah0, &hp0);
}
} else {
bindtextdomain(Z_STRVAL_P(default_domain), Z_STRVAL_P(directory));
}
textdomain(Z_STRVAL_P(default_domain));
PHALCON_MM_RESTORE();
}
/**
* Renders a view using the template engine
*
* @param string $path
* @param array $params
* @param boolean $mustClean
*/
PHP_METHOD(Phalcon_Mvc_View_Engine_Php, render) {
zval *path, *params, *must_clean = NULL, *value = NULL, *key = NULL, *contents;
zval *view;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 1, &path, ¶ms, &must_clean);
if (!must_clean) {
PHALCON_INIT_VAR(must_clean);
ZVAL_BOOL(must_clean, 0);
}
if (PHALCON_IS_TRUE(must_clean)) {
phalcon_ob_clean(TSRMLS_C);
}
/**
* Create the variables in local symbol table
*/
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(value);
if (phalcon_set_symbol(key, value TSRMLS_CC) == FAILURE) {
return;
}
zend_hash_move_forward_ex(ah0, &hp0);
}
}
/**
* Require the file
*/
if (phalcon_require(path TSRMLS_CC) == FAILURE) {
return;
}
if (PHALCON_IS_TRUE(must_clean)) {
PHALCON_INIT_VAR(contents);
phalcon_ob_get_contents(contents TSRMLS_CC);
PHALCON_OBS_VAR(view);
phalcon_read_property_this(&view, this_ptr, SL("_view"), PH_NOISY_CC);
phalcon_call_method_p1_noret(view, "setcontent", contents);
}
PHALCON_MM_RESTORE();
}
/**
* Read the model's column map, this can't be infered
*
* @param Phalcon\Mvc\ModelInterface $model
* @param Phalcon\DiInterface $dependencyInjector
* @return array
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Strategy_Introspection, getColumnMaps) {
zval *model, *dependency_injector, *ordered_column_map = NULL;
zval *reversed_column_map = NULL, *user_column_map;
zval *user_name = NULL, *name = NULL, *model_column_map;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &model, &dependency_injector);
PHALCON_INIT_VAR(ordered_column_map);
PHALCON_INIT_VAR(reversed_column_map);
/**
* Check for a columnMap() method on the model
*/
if (phalcon_method_exists_ex(model, SS("columnmap") TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(user_column_map);
phalcon_call_method(user_column_map, model, "columnmap");
if (Z_TYPE_P(user_column_map) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "columnMap() not returned an array");
return;
}
array_init(reversed_column_map);
PHALCON_CPY_WRT(ordered_column_map, user_column_map);
phalcon_is_iterable(user_column_map, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(name, ah0, hp0);
PHALCON_GET_HVALUE(user_name);
phalcon_array_update_zval(&reversed_column_map, user_name, &name, PH_COPY | PH_SEPARATE);
zend_hash_move_forward_ex(ah0, &hp0);
}
}
/**
* Store the column map
*/
PHALCON_INIT_VAR(model_column_map);
array_init(model_column_map);
phalcon_array_update_long(&model_column_map, 0, &ordered_column_map, PH_COPY | PH_SEPARATE);
phalcon_array_update_long(&model_column_map, 1, &reversed_column_map, PH_COPY | PH_SEPARATE);
RETURN_CTOR(model_column_map);
}
/**
* Sends the headers to the client
*
* @return boolean
*/
PHP_METHOD(Phalcon_Http_Response_Headers, send){
zval *headers, *value = NULL, *header = NULL;
zval *http_header = NULL;
zval copy;
int use_copy;
HashTable *ah0;
HashPosition hp0;
zval **hd;
sapi_header_line ctr = { NULL, 0, 0 };
PHALCON_MM_GROW();
if (!SG(headers_sent)) {
PHALCON_OBS_VAR(headers);
phalcon_read_property_this(&headers, this_ptr, SL("_headers"), PH_NOISY_CC);
phalcon_is_iterable(headers, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(header, ah0, hp0);
PHALCON_GET_HVALUE(value);
if (PHALCON_IS_NOT_EMPTY(value)) {
PHALCON_INIT_NVAR(http_header);
PHALCON_CONCAT_VSV(http_header, header, ": ", value);
ctr.line = Z_STRVAL_P(http_header);
ctr.line_len = Z_STRLEN_P(http_header);
sapi_header_op(SAPI_HEADER_REPLACE, &ctr TSRMLS_CC);
} else {
zend_make_printable_zval(header, ©, &use_copy);
if (unlikely(use_copy)) {
header = ©
}
ctr.line = Z_STRVAL_P(header);
ctr.line_len = Z_STRLEN_P(header);
sapi_header_op(SAPI_HEADER_REPLACE, &ctr TSRMLS_CC);
if (unlikely(use_copy)) {
zval_dtor(©);
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
RETURN_MM_TRUE;
}
RETURN_MM_FALSE;
}
/**
* Returns the annotations found in the properties' docblocks
*
* @return Phalcon\Annotations\Collection[]
*/
PHP_METHOD(Phalcon_Annotations_Reflection, getPropertiesAnnotations){
zval *annotations, *reflection_data, *reflection_properties;
zval *collections, *reflection_property = NULL, *property = NULL;
zval *collection = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(annotations);
phalcon_read_property_this(&annotations, this_ptr, SL("_propertyAnnotations"), PH_NOISY_CC);
if (Z_TYPE_P(annotations) != IS_OBJECT) {
PHALCON_OBS_VAR(reflection_data);
phalcon_read_property_this(&reflection_data, this_ptr, SL("_reflectionData"), PH_NOISY_CC);
if (phalcon_array_isset_string(reflection_data, SS("properties"))) {
PHALCON_OBS_VAR(reflection_properties);
phalcon_array_fetch_string(&reflection_properties, reflection_data, SL("properties"), PH_NOISY_CC);
if (phalcon_fast_count_ev(reflection_properties TSRMLS_CC)) {
PHALCON_INIT_VAR(collections);
array_init(collections);
phalcon_is_iterable(reflection_properties, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(property, ah0, hp0);
PHALCON_GET_HVALUE(reflection_property);
PHALCON_INIT_NVAR(collection);
object_init_ex(collection, phalcon_annotations_collection_ce);
phalcon_call_method_p1_noret(collection, "__construct", reflection_property);
phalcon_array_update_zval(&collections, property, &collection, PH_COPY | PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
}
phalcon_update_property_this(this_ptr, SL("_propertyAnnotations"), collections TSRMLS_CC);
RETURN_CTOR(collections);
}
}
phalcon_update_property_bool(this_ptr, SL("_propertyAnnotations"), 0 TSRMLS_CC);
RETURN_MM_FALSE;
}
RETURN_CCTOR(annotations);
}
/**
* Returns the translation related to the given key
*
* @param string $index
* @param array $placeholders
* @return string
*/
PHP_METHOD(Phalcon_Translate_Adapter_NativeArray, query){
zval *index, *placeholders = NULL, *translate, *translation = NULL;
zval *value = NULL, *key = NULL, *key_placeholder = NULL, *replaced = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &index, &placeholders);
if (!placeholders) {
PHALCON_INIT_VAR(placeholders);
}
PHALCON_OBS_VAR(translate);
phalcon_read_property_this(&translate, this_ptr, SL("_translate"), PH_NOISY_CC);
if (phalcon_array_isset(translate, index)) {
PHALCON_OBS_VAR(translation);
phalcon_array_fetch(&translation, translate, index, PH_NOISY);
if (Z_TYPE_P(placeholders) == IS_ARRAY) {
if (phalcon_fast_count_ev(placeholders TSRMLS_CC)) {
phalcon_is_iterable(placeholders, &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_INIT_NVAR(key_placeholder);
PHALCON_CONCAT_SVS(key_placeholder, "%", key, "%");
PHALCON_INIT_NVAR(replaced);
phalcon_fast_str_replace(replaced, key_placeholder, value, translation);
PHALCON_CPY_WRT(translation, replaced);
zend_hash_move_forward_ex(ah0, &hp0);
}
}
}
RETURN_CCTOR(translation);
}
RETURN_CCTOR(index);
}
/**
* Returns the translation related to the given key
*
* @param string $index
* @param array $placeholders
* @param string $domain
* @return string
*/
PHP_METHOD(Phalcon_Translate_Adapter_Gettext, query){
zval *index, *placeholders = NULL, *domain = NULL;
zval *translation, *key = NULL, *value = NULL, *key_placeholder = NULL, *replaced = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *msgstr;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 2, &index, &placeholders, &domain);
if (!domain) {
msgstr = gettext(Z_STRVAL_P(index));
} else {
msgstr = dgettext(Z_STRVAL_P(domain), Z_STRVAL_P(index));
}
PHALCON_INIT_VAR(translation);
ZVAL_STRING(translation, msgstr, 1);
if (placeholders && Z_TYPE_P(placeholders) == IS_ARRAY && zend_hash_num_elements(Z_ARRVAL_P(placeholders))) {
phalcon_is_iterable(placeholders, &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_INIT_NVAR(key_placeholder);
PHALCON_CONCAT_SVS(key_placeholder, "%", key, "%");
PHALCON_INIT_NVAR(replaced);
phalcon_fast_str_replace(replaced, key_placeholder, value, translation);
PHALCON_CPY_WRT(translation, replaced);
zend_hash_move_forward_ex(ah0, &hp0);
}
}
RETURN_CTOR(translation);
}
/**
* Builds a Phalcon\Mvc\Model\Criteria based on an input array like $_POST
*
* @param Phalcon\DiInterface $dependencyInjector
* @param string $modelName
* @param array $data
* @return static
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, fromInput){
zval *dependency_injector, *model_name, *data;
zval *conditions, *service, *meta_data, *model;
zval *data_types, *bind, *value = NULL, *field = NULL, *type = NULL, *condition = NULL;
zval *value_pattern = NULL, *criteria, *join_conditions;
HashTable *ah0;
HashPosition hp0;
zval **hd;
zend_class_entry *ce0;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 3, 0, &dependency_injector, &model_name, &data);
if (Z_TYPE_P(data) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Input data must be an Array");
return;
}
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "A dependency injector container is required to obtain the ORM services");
return;
}
PHALCON_INIT_VAR(conditions);
array_init(conditions);
if (phalcon_fast_count_ev(data TSRMLS_CC)) {
PHALCON_INIT_VAR(service);
ZVAL_STRING(service, "modelsMetadata", 1);
PHALCON_INIT_VAR(meta_data);
phalcon_call_method_p1(meta_data, dependency_injector, "getshared", service);
ce0 = phalcon_fetch_class(model_name TSRMLS_CC);
PHALCON_INIT_VAR(model);
object_init_ex(model, ce0);
if (phalcon_has_constructor(model TSRMLS_CC)) {
phalcon_call_method_noret(model, "__construct");
}
PHALCON_INIT_VAR(data_types);
phalcon_call_method_p1(data_types, meta_data, "getdatatypes", model);
PHALCON_INIT_VAR(bind);
array_init(bind);
/**
* We look for attributes in the array passed as data
*/
phalcon_is_iterable(data, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(field, ah0, hp0);
PHALCON_GET_HVALUE(value);
if (phalcon_array_isset(data_types, field)) {
if (Z_TYPE_P(value) != IS_NULL) {
if (!PHALCON_IS_STRING(value, "")) {
PHALCON_OBS_NVAR(type);
phalcon_array_fetch(&type, data_types, field, PH_NOISY_CC);
if (PHALCON_IS_LONG(type, 2)) {
/**
* For varchar types we use LIKE operator
*/
PHALCON_INIT_NVAR(condition);
PHALCON_CONCAT_VSVS(condition, field, " LIKE :", field, ":");
PHALCON_INIT_NVAR(value_pattern);
PHALCON_CONCAT_SVS(value_pattern, "%", value, "%");
phalcon_array_update_zval(&bind, field, &value_pattern, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
/**
* For the rest of data types we use a plain = operator
*/
PHALCON_INIT_NVAR(condition);
PHALCON_CONCAT_VSVS(condition, field, "=:", field, ":");
phalcon_array_update_zval(&bind, field, &value, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
phalcon_array_append(&conditions, condition, PH_SEPARATE TSRMLS_CC);
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
}
/**
* Create an object instance and pass the paramaters to it
*/
PHALCON_INIT_VAR(criteria);
object_init_ex(criteria, phalcon_mvc_model_criteria_ce);
if (phalcon_fast_count_ev(conditions TSRMLS_CC)) {
PHALCON_INIT_VAR(join_conditions);
phalcon_fast_join_str(join_conditions, SL(" AND "), conditions TSRMLS_CC);
phalcon_call_method_p1_noret(criteria, "where", join_conditions);
phalcon_call_method_p1_noret(criteria, "bind", bind);
}
RETURN_CTOR(criteria);
}
/**
* Tries to render the view with every engine registered in the component
*
* @param string $path
* @param array $params
*/
PHP_METHOD(Phalcon_Mvc_View_Simple, _internalRender){
zval *path, *params, *events_manager, *event_name = NULL;
zval *status = NULL, *not_exists = NULL, *must_clean, *views_dir;
zval *views_dir_path, *engines, *engine = NULL, *extension = NULL;
zval *view_engine_path = NULL, *exception_message;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &path, ¶ms);
PHALCON_OBS_VAR(events_manager);
phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_this(this_ptr, SL("_activeRenderPath"), path TSRMLS_CC);
}
/**
* Call beforeRender if there is an events manager
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "view:beforeRender", 1);
PHALCON_INIT_VAR(status);
phalcon_call_method_p2(status, events_manager, "fire", event_name, this_ptr);
if (PHALCON_IS_FALSE(status)) {
RETURN_MM_NULL();
}
}
PHALCON_INIT_VAR(not_exists);
ZVAL_BOOL(not_exists, 1);
PHALCON_INIT_VAR(must_clean);
ZVAL_BOOL(must_clean, 1);
PHALCON_OBS_VAR(views_dir);
phalcon_read_property_this(&views_dir, this_ptr, SL("_viewsDir"), PH_NOISY_CC);
PHALCON_INIT_VAR(views_dir_path);
PHALCON_CONCAT_VV(views_dir_path, views_dir, path);
/**
* Load the template engines
*/
PHALCON_INIT_VAR(engines);
phalcon_call_method(engines, this_ptr, "_loadtemplateengines");
/**
* Views are rendered in each engine
*/
phalcon_is_iterable(engines, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(extension, ah0, hp0);
PHALCON_GET_HVALUE(engine);
PHALCON_INIT_NVAR(view_engine_path);
PHALCON_CONCAT_VV(view_engine_path, views_dir_path, extension);
if (phalcon_file_exists(view_engine_path TSRMLS_CC) == SUCCESS) {
/**
* Call beforeRenderView if there is a events manager available
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "view:beforeRenderView", 1);
PHALCON_INIT_NVAR(status);
phalcon_call_method_p3(status, events_manager, "fire", event_name, this_ptr, view_engine_path);
if (PHALCON_IS_FALSE(status)) {
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
}
phalcon_call_method_p3_noret(engine, "render", view_engine_path, params, must_clean);
/**
* Call afterRenderView if there is a events manager available
*/
PHALCON_INIT_NVAR(not_exists);
ZVAL_BOOL(not_exists, 0);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "view:afterRenderView", 1);
phalcon_call_method_p2_noret(events_manager, "fire", event_name, this_ptr);
}
break;
}
zend_hash_move_forward_ex(ah0, &hp0);
}
/**
* Always throw an exception if the view does not exist
*/
if (PHALCON_IS_TRUE(not_exists)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "View '", views_dir_path, "' was not found in the views directory");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_view_exception_ce, exception_message);
return;
}
/**
* Call afterRender event
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "view:afterRender", 1);
phalcon_call_method_p2_noret(events_manager, "fire", event_name, this_ptr);
}
PHALCON_MM_RESTORE();
}
/**
* Loads registered template engines, if none is registered it will use Phalcon\Mvc\View\Engine\Php
*
* @return array
*/
PHP_METHOD(Phalcon_Mvc_View_Simple, _loadTemplateEngines){
zval *engines = NULL, *dependency_injector, *registered_engines;
zval *php_engine, *arguments, *engine_service = NULL;
zval *extension = NULL, *engine_object = NULL, *exception_message = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(engines);
phalcon_read_property_this(&engines, this_ptr, SL("_engines"), PH_NOISY_CC);
/**
* If the engines aren't initialized 'engines' is false
*/
if (PHALCON_IS_FALSE(engines)) {
PHALCON_OBS_VAR(dependency_injector);
phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
PHALCON_INIT_NVAR(engines);
array_init(engines);
PHALCON_OBS_VAR(registered_engines);
phalcon_read_property_this(®istered_engines, this_ptr, SL("_registeredEngines"), PH_NOISY_CC);
if (Z_TYPE_P(registered_engines) != IS_ARRAY) {
/**
* We use Phalcon\Mvc\View\Engine\Php as default
*/
PHALCON_INIT_VAR(php_engine);
object_init_ex(php_engine, phalcon_mvc_view_engine_php_ce);
phalcon_call_method_p2_noret(php_engine, "__construct", this_ptr, dependency_injector);
/**
* Use .phtml as extension for the PHP engine
*/
phalcon_array_update_string(&engines, SL(".phtml"), &php_engine, PH_COPY | PH_SEPARATE);
} else {
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_view_exception_ce, "A dependency injector container is required to obtain the application services");
return;
}
/**
* Arguments for instantiated engines
*/
PHALCON_INIT_VAR(arguments);
array_init_size(arguments, 2);
phalcon_array_append(&arguments, this_ptr, PH_SEPARATE);
phalcon_array_append(&arguments, dependency_injector, PH_SEPARATE);
phalcon_is_iterable(registered_engines, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(extension, ah0, hp0);
PHALCON_GET_HVALUE(engine_service);
if (Z_TYPE_P(engine_service) == IS_OBJECT) {
/**
* Engine can be a closure
*/
if (phalcon_is_instance_of(engine_service, SL("Closure") TSRMLS_CC)) {
PHALCON_INIT_NVAR(engine_object);
PHALCON_CALL_USER_FUNC_ARRAY(engine_object, engine_service, arguments);
} else {
PHALCON_CPY_WRT(engine_object, engine_service);
}
} else {
/**
* Engine can be a string representing a service in the DI
*/
if (Z_TYPE_P(engine_service) == IS_STRING) {
PHALCON_INIT_NVAR(engine_object);
phalcon_call_method_p2(engine_object, dependency_injector, "getshared", engine_service, arguments);
} else {
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SV(exception_message, "Invalid template engine registration for extension: ", extension);
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_view_exception_ce, exception_message);
return;
}
}
phalcon_array_update_zval(&engines, extension, &engine_object, PH_COPY | PH_SEPARATE);
zend_hash_move_forward_ex(ah0, &hp0);
}
}
phalcon_update_property_this(this_ptr, SL("_engines"), engines TSRMLS_CC);
} else {
PHALCON_OBS_NVAR(engines);
phalcon_read_property_this(&engines, this_ptr, SL("_engines"), PH_NOISY_CC);
}
RETURN_CCTOR(engines);
}
/**
* Executes a prepared statement binding. This function uses integer indexes starting from zero
*
*<code>
* $statement = $connection->prepare('SELECT * FROM robots WHERE name = :name');
* $pdoResult = $connection->executePrepared($statement, array('name' => 'Voltron'));
*</code>
*
* @param \PDOStatement $statement
* @param array $placeholders
* @param array $dataTypes
* @return \PDOStatement
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, executePrepared){
zval *statement = NULL, *placeholders = NULL, *data_types = NULL;
zval *z_one, *value = NULL, *wildcard = NULL, *parameter = NULL, *type = NULL, *cast_value = NULL;
zval *profiler, *sql_statement;
HashTable *ah0;
HashPosition hp0;
zval **hd;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &statement, &placeholders, &data_types) == FAILURE) {
RETURN_NULL();
}
PHALCON_MM_GROW();
z_one = PHALCON_GLOBAL(z_one);
phalcon_is_iterable(placeholders, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(wildcard, ah0, hp0);
PHALCON_GET_HVALUE(value);
if (Z_TYPE_P(wildcard) == IS_LONG) {
PHALCON_INIT_NVAR(parameter);
phalcon_add_function(parameter, wildcard, z_one);
} else {
if (Z_TYPE_P(wildcard) == IS_STRING) {
PHALCON_CPY_WRT(parameter, wildcard);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter");
return;
}
}
if (Z_TYPE_P(data_types) == IS_ARRAY) {
if (likely(phalcon_array_isset(data_types, wildcard))) {
/**
* The bind type is double so we try to get the double value
*/
PHALCON_OBS_NVAR(type);
phalcon_array_fetch(&type, data_types, wildcard, PH_NOISY);
if (phalcon_compare_strict_long(type, 32 TSRMLS_CC)) {
PHALCON_INIT_NVAR(cast_value);
phalcon_cast(cast_value, value, IS_DOUBLE);
PHALCON_INIT_NVAR(type);
ZVAL_LONG(type, 1024);
} else {
PHALCON_CPY_WRT(cast_value, value);
}
/**
* 1024 is ignore the bind type
*/
Z_SET_ISREF_P(cast_value);
if (phalcon_compare_strict_long(type, 1024 TSRMLS_CC)) {
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, cast_value);
} else {
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, cast_value, type);
}
Z_UNSET_ISREF_P(cast_value);
} else {
PHALCON_INIT_NVAR(type);
if (Z_TYPE_P(value) == IS_LONG) {
ZVAL_LONG(type, 1 /* BIND_PARAM_INT */);
}
else {
ZVAL_LONG(type, 2 /* BIND_PARAM_STR */);
}
Z_SET_ISREF_P(value);
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, value, type);
Z_UNSET_ISREF_P(value);
/*
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind type parameter");
return;
*/
}
} else {
Z_SET_ISREF_P(value);
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, value);
Z_UNSET_ISREF_P(value);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
profiler = phalcon_fetch_nproperty_this(this_ptr, SL("_profiler"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(profiler) == IS_OBJECT) {
sql_statement = phalcon_fetch_nproperty_this(this_ptr, SL("_sqlStatement"), PH_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD(NULL, profiler, "startprofile", sql_statement, placeholders, data_types);
PHALCON_CALL_METHOD(NULL, statement, "execute");
PHALCON_CALL_METHOD(NULL, profiler, "stopprofile");
} else {
PHALCON_CALL_METHOD(NULL, statement, "execute");
}
RETURN_CTOR(statement);
}
/**
* This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
* Call it when you need to restore a database connection
*
*<code>
* //Make a connection
* $connection = new Phalcon\Db\Adapter\Pdo\Mysql(array(
* 'host' => '192.168.0.11',
* 'username' => 'sigma',
* 'password' => 'secret',
* 'dbname' => 'blog',
* ));
*
* //Reconnect
* $connection->connect();
* </code>
*
* @param array $descriptor
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, connect){
zval *descriptor = NULL, *username = NULL, *password = NULL, *dsn_parts;
zval *value = NULL, *key = NULL, *dsn_attribute = NULL, *dsn_attributes = NULL;
zval *pdo_type, *dsn, *options = NULL, *persistent, *pdo;
zend_class_entry *ce;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &descriptor) == FAILURE) {
RETURN_MM_NULL();
}
if (!descriptor) {
PHALCON_INIT_VAR(descriptor);
} else {
PHALCON_SEPARATE_PARAM(descriptor);
}
if (Z_TYPE_P(descriptor) == IS_NULL) {
PHALCON_OBS_NVAR(descriptor);
phalcon_read_property(&descriptor, this_ptr, SL("_descriptor"), PH_NOISY TSRMLS_CC);
}
/**
* Check for a username or use null as default
*/
if (phalcon_array_isset_string(descriptor, SS("username"))) {
PHALCON_OBS_VAR(username);
phalcon_array_fetch_string(&username, descriptor, SL("username"), PH_NOISY);
phalcon_array_unset_string(&descriptor, SS("username"), PH_COPY);
} else {
PHALCON_INIT_NVAR(username);
}
/**
* Check for a password or use null as default
*/
if (phalcon_array_isset_string(descriptor, SS("password"))) {
PHALCON_OBS_VAR(password);
phalcon_array_fetch_string(&password, descriptor, SL("password"), PH_NOISY);
phalcon_array_unset_string(&descriptor, SS("password"), PH_COPY);
} else {
PHALCON_INIT_NVAR(password);
}
/**
* Check if the developer has defined custom options or create one from scratch
*/
if (phalcon_array_isset_string(descriptor, SS("options"))) {
PHALCON_OBS_VAR(options);
phalcon_array_fetch_string(&options, descriptor, SL("options"), PH_NOISY);
phalcon_array_unset_string(&descriptor, SS("options"), PH_COPY);
} else {
PHALCON_INIT_NVAR(options);
array_init(options);
}
/**
* Remove the dialectClass from the descriptor if any
*/
if (phalcon_array_isset_string(descriptor, SS("dialectClass"))) {
phalcon_array_unset_string(&descriptor, SS("dialectClass"), PH_COPY);
}
/**
* Check if the user has defined a custom dsn
*/
if (!phalcon_array_isset_string(descriptor, SS("dsn"))) {
PHALCON_INIT_VAR(dsn_parts);
array_init(dsn_parts);
phalcon_is_iterable(descriptor, &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_INIT_NVAR(dsn_attribute);
PHALCON_CONCAT_VSV(dsn_attribute, key, "=", value);
phalcon_array_append(&dsn_parts, dsn_attribute, PH_COPY);
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(dsn_attributes);
phalcon_fast_join_str(dsn_attributes, SL(";"), dsn_parts TSRMLS_CC);
} else {
PHALCON_OBS_NVAR(dsn_attributes);
phalcon_array_fetch_string(&dsn_attributes, descriptor, SL("dsn"), PH_NOISY);
}
PHALCON_OBS_VAR(pdo_type);
phalcon_read_property(&pdo_type, this_ptr, SL("_type"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(dsn);
PHALCON_CONCAT_VSV(dsn, pdo_type, ":", dsn_attributes);
/**
* Default options
*/
phalcon_array_update_long_long(&options, PDO_ATTR_ERRMODE, PDO_ERRMODE_EXCEPTION, PH_COPY);
/*
phalcon_array_update_long_long(&options, PDO_ATTR_CASE, PDO_CASE_LOWER, PH_COPY);
phalcon_array_update_long_long(&options, PDO_ATTR_CURSOR, PDO_CURSOR_SCROLL, PH_COPY);
*/
/**
* Check if the connection must be persistent
*/
if (phalcon_array_isset_string(descriptor, SS("persistent"))) {
PHALCON_OBS_VAR(persistent);
phalcon_array_fetch_string(&persistent, descriptor, SL("persistent"), PH_NOISY);
if (zend_is_true(persistent)) {
phalcon_array_update_long_bool(&options, PDO_ATTR_PERSISTENT, 1, PH_COPY);
}
}
/**
* Create the connection using PDO
*/
ce = zend_fetch_class(SL("PDO"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_INIT_VAR(pdo);
object_init_ex(pdo, ce);
PHALCON_CALL_METHOD(NULL, pdo, "__construct", dsn, username, password, options);
phalcon_update_property_zval(this_ptr, SL("_pdo"), pdo TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Returns a PHQL statement built based on the builder parameters
*
* @return string
*/
PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql){
zval *dependency_injector = NULL, *models, *conditions = NULL;
zval *one, *number_models, *invalid_condition;
zval *model = NULL, *service_name, *meta_data, *model_instance;
zval *no_primary = NULL, *primary_keys, *first_primary_key;
zval *column_map = NULL, *attribute_field = NULL, *exception_message;
zval *primary_key_condition, *phql, *columns;
zval *selected_columns = NULL, *column = NULL, *column_alias = NULL;
zval *aliased_column = NULL, *joined_columns = NULL, *model_column_alias = NULL;
zval *selected_column = NULL, *selected_models, *model_alias = NULL;
zval *selected_model = NULL, *joined_models, *joins;
zval *join = NULL, *join_model = NULL, *join_conditions = NULL, *join_alias = NULL;
zval *join_type = NULL, *group, *group_items, *group_item = NULL;
zval *escaped_item = NULL, *joined_items = NULL, *having, *order;
zval *order_items, *order_item = NULL, *limit, *number;
zval *offset = NULL;
HashTable *ah0, *ah1, *ah2, *ah3, *ah4, *ah5;
HashPosition hp0, hp1, hp2, hp3, hp4, hp5;
zval **hd;
zend_class_entry *ce0;
PHALCON_MM_GROW();
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");
phalcon_update_property_this(this_ptr, SL("_dependencyInjector"), dependency_injector TSRMLS_CC);
}
PHALCON_OBS_VAR(models);
phalcon_read_property_this(&models, this_ptr, SL("_models"), PH_NOISY_CC);
if (Z_TYPE_P(models) == IS_ARRAY) {
if (!phalcon_fast_count_ev(models TSRMLS_CC)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "At least one model is required to build the query");
return;
}
} else {
if (!zend_is_true(models)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "At least one model is required to build the query");
return;
}
}
PHALCON_OBS_VAR(conditions);
phalcon_read_property_this(&conditions, this_ptr, SL("_conditions"), PH_NOISY_CC);
if (phalcon_is_numeric(conditions)) {
/**
* If the conditions is a single numeric field. We internally create a condition
* using the related primary key
*/
if (Z_TYPE_P(models) == IS_ARRAY) {
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_INIT_VAR(number_models);
phalcon_fast_count(number_models, models TSRMLS_CC);
PHALCON_INIT_VAR(invalid_condition);
is_smaller_function(invalid_condition, one, number_models TSRMLS_CC);
if (PHALCON_IS_TRUE(invalid_condition)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Cannot build the query. Invalid condition");
return;
}
PHALCON_OBS_VAR(model);
phalcon_array_fetch_long(&model, models, 0, PH_NOISY);
} else {
PHALCON_CPY_WRT(model, models);
}
PHALCON_INIT_VAR(service_name);
ZVAL_STRING(service_name, "modelsMetadata", 1);
/**
* Get the models metadata service to obtain the column names, column map and
* primary key
*/
PHALCON_INIT_VAR(meta_data);
phalcon_call_method_p1(meta_data, dependency_injector, "getshared", service_name);
ce0 = phalcon_fetch_class(model TSRMLS_CC);
PHALCON_INIT_VAR(model_instance);
object_init_ex(model_instance, ce0);
if (phalcon_has_constructor(model_instance TSRMLS_CC)) {
phalcon_call_method_p1_noret(model_instance, "__construct", dependency_injector);
}
PHALCON_INIT_VAR(no_primary);
ZVAL_BOOL(no_primary, 1);
PHALCON_INIT_VAR(primary_keys);
phalcon_call_method_p1(primary_keys, meta_data, "getprimarykeyattributes", model_instance);
if (phalcon_fast_count_ev(primary_keys TSRMLS_CC)) {
if (phalcon_array_isset_long(primary_keys, 0)) {
PHALCON_OBS_VAR(first_primary_key);
phalcon_array_fetch_long(&first_primary_key, primary_keys, 0, PH_NOISY);
/**
* The PHQL contains the renamed columns if available
*/
if (PHALCON_GLOBAL(orm).column_renaming) {
PHALCON_INIT_VAR(column_map);
phalcon_call_method_p1(column_map, meta_data, "getcolumnmap", model_instance);
} else {
PHALCON_INIT_NVAR(column_map);
}
if (Z_TYPE_P(column_map) == IS_ARRAY) {
if (phalcon_array_isset(column_map, first_primary_key)) {
PHALCON_OBS_VAR(attribute_field);
phalcon_array_fetch(&attribute_field, column_map, first_primary_key, PH_NOISY);
} else {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Column '", first_primary_key, "\" 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, first_primary_key);
}
PHALCON_INIT_VAR(primary_key_condition);
PHALCON_CONCAT_SVSVSV(primary_key_condition, "[", model, "].[", attribute_field, "] = ", conditions);
PHALCON_CPY_WRT(conditions, primary_key_condition);
ZVAL_BOOL(no_primary, 0);
}
}
/**
* A primary key is mandatory in these cases
*/
if (PHALCON_IS_TRUE(no_primary)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Source related to this model does not have a primary key defined");
return;
}
}
PHALCON_INIT_VAR(phql);
ZVAL_STRING(phql, "SELECT ", 1);
PHALCON_OBS_VAR(columns);
phalcon_read_property_this(&columns, this_ptr, SL("_columns"), PH_NOISY_CC);
if (Z_TYPE_P(columns) != IS_NULL) {
/**
* Generate PHQL for columns
*/
if (Z_TYPE_P(columns) == IS_ARRAY) {
PHALCON_INIT_VAR(selected_columns);
array_init(selected_columns);
phalcon_is_iterable(columns, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(column_alias, ah0, hp0);
PHALCON_GET_HVALUE(column);
if (Z_TYPE_P(column_alias) == IS_LONG) {
phalcon_array_append(&selected_columns, column, PH_SEPARATE);
} else {
PHALCON_INIT_NVAR(aliased_column);
PHALCON_CONCAT_VSV(aliased_column, column, " AS ", column_alias);
phalcon_array_append(&selected_columns, aliased_column, PH_SEPARATE);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(joined_columns);
phalcon_fast_join_str(joined_columns, SL(", "), selected_columns TSRMLS_CC);
phalcon_concat_self(&phql, joined_columns TSRMLS_CC);
} else {
phalcon_concat_self(&phql, columns TSRMLS_CC);
}
} else {
/**
* Automatically generate an array of models
*/
if (Z_TYPE_P(models) == IS_ARRAY) {
PHALCON_INIT_NVAR(selected_columns);
array_init(selected_columns);
phalcon_is_iterable(models, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HKEY(model_column_alias, ah1, hp1);
PHALCON_GET_HVALUE(model);
if (Z_TYPE_P(model_column_alias) == IS_LONG) {
PHALCON_INIT_NVAR(selected_column);
PHALCON_CONCAT_SVS(selected_column, "[", model, "].*");
} else {
PHALCON_INIT_NVAR(selected_column);
PHALCON_CONCAT_SVS(selected_column, "[", model_column_alias, "].*");
}
phalcon_array_append(&selected_columns, selected_column, PH_SEPARATE);
zend_hash_move_forward_ex(ah1, &hp1);
}
PHALCON_INIT_NVAR(joined_columns);
phalcon_fast_join_str(joined_columns, SL(", "), selected_columns TSRMLS_CC);
phalcon_concat_self(&phql, joined_columns TSRMLS_CC);
} else {
PHALCON_SCONCAT_SVS(phql, "[", models, "].*");
}
}
/**
* Join multiple models or use a single one if it is a string
*/
if (Z_TYPE_P(models) == IS_ARRAY) {
PHALCON_INIT_VAR(selected_models);
array_init(selected_models);
phalcon_is_iterable(models, &ah2, &hp2, 0, 0);
while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) {
PHALCON_GET_HKEY(model_alias, ah2, hp2);
PHALCON_GET_HVALUE(model);
if (Z_TYPE_P(model_alias) == IS_STRING) {
PHALCON_INIT_NVAR(selected_model);
PHALCON_CONCAT_SVSVS(selected_model, "[", model, "] AS [", model_alias, "]");
} else {
PHALCON_INIT_NVAR(selected_model);
PHALCON_CONCAT_SVS(selected_model, "[", model, "]");
}
phalcon_array_append(&selected_models, selected_model, PH_SEPARATE);
zend_hash_move_forward_ex(ah2, &hp2);
}
PHALCON_INIT_VAR(joined_models);
phalcon_fast_join_str(joined_models, SL(", "), selected_models TSRMLS_CC);
PHALCON_SCONCAT_SV(phql, " FROM ", joined_models);
} else {
PHALCON_SCONCAT_SVS(phql, " FROM [", models, "]");
}
/**
* Check if joins were passed to the builders
*/
PHALCON_OBS_VAR(joins);
phalcon_read_property_this(&joins, this_ptr, SL("_joins"), PH_NOISY_CC);
if (Z_TYPE_P(joins) == IS_ARRAY) {
phalcon_is_iterable(joins, &ah3, &hp3, 0, 0);
while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) {
PHALCON_GET_HVALUE(join);
/**
* The joined table is in the first place of the array
*/
PHALCON_OBS_NVAR(join_model);
phalcon_array_fetch_long(&join_model, join, 0, PH_NOISY);
/**
* The join conditions are in the second place of the array
*/
PHALCON_OBS_NVAR(join_conditions);
phalcon_array_fetch_long(&join_conditions, join, 1, PH_NOISY);
/**
* The join alias is in the second place of the array
*/
PHALCON_OBS_NVAR(join_alias);
phalcon_array_fetch_long(&join_alias, join, 2, PH_NOISY);
/**
* Join type
*/
PHALCON_OBS_NVAR(join_type);
phalcon_array_fetch_long(&join_type, join, 3, PH_NOISY);
/**
* Create the join according to the type
*/
if (zend_is_true(join_type)) {
PHALCON_SCONCAT_SVSVS(phql, " ", join_type, " JOIN [", join_model, "]");
} else {
PHALCON_SCONCAT_SVS(phql, " JOIN [", join_model, "]");
}
/**
* Alias comes first
*/
if (zend_is_true(join_alias)) {
PHALCON_SCONCAT_SVS(phql, " AS [", join_alias, "]");
}
/**
* Conditions then
*/
if (zend_is_true(join_conditions)) {
PHALCON_SCONCAT_SV(phql, " ON ", join_conditions);
}
zend_hash_move_forward_ex(ah3, &hp3);
}
}
/**
* Only append conditions if it's string
*/
if (Z_TYPE_P(conditions) == IS_STRING) {
if (PHALCON_IS_NOT_EMPTY(conditions)) {
PHALCON_SCONCAT_SV(phql, " WHERE ", conditions);
}
}
/**
* Process group parameters
*/
PHALCON_OBS_VAR(group);
phalcon_read_property_this(&group, this_ptr, SL("_group"), PH_NOISY_CC);
if (Z_TYPE_P(group) != IS_NULL) {
if (Z_TYPE_P(group) == IS_ARRAY) {
PHALCON_INIT_VAR(group_items);
array_init(group_items);
phalcon_is_iterable(group, &ah4, &hp4, 0, 0);
while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) {
PHALCON_GET_HVALUE(group_item);
if (phalcon_is_numeric(group_item)) {
phalcon_array_append(&group_items, group_item, PH_SEPARATE);
} else {
if (phalcon_memnstr_str(group_item, SL("."))) {
phalcon_array_append(&group_items, group_item, PH_SEPARATE);
} else {
PHALCON_INIT_NVAR(escaped_item);
PHALCON_CONCAT_SVS(escaped_item, "[", group_item, "]");
phalcon_array_append(&group_items, escaped_item, PH_SEPARATE);
}
}
zend_hash_move_forward_ex(ah4, &hp4);
}
PHALCON_INIT_VAR(joined_items);
phalcon_fast_join_str(joined_items, SL(", "), group_items TSRMLS_CC);
PHALCON_SCONCAT_SV(phql, " GROUP BY ", joined_items);
} else {
if (phalcon_is_numeric(group)) {
PHALCON_SCONCAT_SV(phql, " GROUP BY ", group);
} else {
if (phalcon_memnstr_str(group, SL("."))) {
PHALCON_SCONCAT_SV(phql, " GROUP BY ", group);
} else {
PHALCON_SCONCAT_SVS(phql, " GROUP BY [", group, "]");
}
}
}
PHALCON_OBS_VAR(having);
phalcon_read_property_this(&having, this_ptr, SL("_having"), PH_NOISY_CC);
if (Z_TYPE_P(having) != IS_NULL) {
if (PHALCON_IS_NOT_EMPTY(having)) {
PHALCON_SCONCAT_SV(phql, " HAVING ", having);
}
}
}
/**
* Process order clause
*/
PHALCON_OBS_VAR(order);
phalcon_read_property_this(&order, this_ptr, SL("_order"), PH_NOISY_CC);
if (Z_TYPE_P(order) != IS_NULL) {
if (Z_TYPE_P(order) == IS_ARRAY) {
PHALCON_INIT_VAR(order_items);
array_init(order_items);
phalcon_is_iterable(order, &ah5, &hp5, 0, 0);
while (zend_hash_get_current_data_ex(ah5, (void**) &hd, &hp5) == SUCCESS) {
PHALCON_GET_HVALUE(order_item);
if (phalcon_is_numeric(order_item)) {
phalcon_array_append(&order_items, order_item, PH_SEPARATE);
} else {
if (phalcon_memnstr_str(order_item, SL("."))) {
phalcon_array_append(&order_items, order_item, PH_SEPARATE);
} else {
PHALCON_INIT_NVAR(escaped_item);
PHALCON_CONCAT_SVS(escaped_item, "[", order_item, "]");
phalcon_array_append(&order_items, escaped_item, PH_SEPARATE);
}
}
zend_hash_move_forward_ex(ah5, &hp5);
}
PHALCON_INIT_NVAR(joined_items);
phalcon_fast_join_str(joined_items, SL(", "), order_items TSRMLS_CC);
PHALCON_SCONCAT_SV(phql, " ORDER BY ", joined_items);
} else {
PHALCON_SCONCAT_SV(phql, " ORDER BY ", order);
}
}
/**
* Process limit parameters
*/
PHALCON_OBS_VAR(limit);
phalcon_read_property_this(&limit, this_ptr, SL("_limit"), PH_NOISY_CC);
if (Z_TYPE_P(limit) != IS_NULL) {
if (Z_TYPE_P(limit) == IS_ARRAY) {
PHALCON_OBS_VAR(number);
phalcon_array_fetch_string(&number, limit, SL("number"), PH_NOISY);
if (phalcon_array_isset_string(limit, SS("offset"))) {
PHALCON_OBS_VAR(offset);
phalcon_array_fetch_string(&offset, limit, SL("offset"), PH_NOISY);
if (phalcon_is_numeric(offset)) {
PHALCON_SCONCAT_SVSV(phql, " LIMIT ", number, " OFFSET ", offset);
} else {
PHALCON_SCONCAT_SVS(phql, " LIMIT ", number, " OFFSET 0");
}
} else {
PHALCON_SCONCAT_SV(phql, " LIMIT ", number);
}
} else {
if (phalcon_is_numeric(limit)) {
PHALCON_SCONCAT_SV(phql, " LIMIT ", limit);
PHALCON_OBS_NVAR(offset);
phalcon_read_property_this(&offset, this_ptr, SL("_offset"), PH_NOISY_CC);
if (Z_TYPE_P(offset) != IS_NULL) {
if (phalcon_is_numeric(offset)) {
PHALCON_SCONCAT_SV(phql, " OFFSET ", offset);
} else {
phalcon_concat_self_str(&phql, SL(" OFFSET 0") TSRMLS_CC);
}
}
}
}
}
RETURN_CTOR(phql);
}
/**
* 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();
}
/**
* Produce the routing parameters from the rewrite information
*
* @param string $uri
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, handle){
zval *uri = NULL, *real_uri = NULL, *processed, *annotations_service = NULL;
zval *handlers, *controller_suffix, *scope = NULL, *prefix = NULL;
zval *dependency_injector = NULL, *service = NULL, *handler = NULL;
zval *controller_name = NULL;
zval *namespace_name = NULL, *module_name = NULL, *suffixed = NULL;
zval *handler_annotations = NULL, *class_annotations = NULL;
zval *annotations = NULL, *annotation = NULL, *method_annotations = NULL;
zval *collection = NULL, *method = NULL;
HashTable *ah0, *ah1, *ah2, *ah3;
HashPosition hp0, hp1, hp2, hp3;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, &uri);
if (!uri) {
uri = PHALCON_GLOBAL(z_null);
}
if (!zend_is_true(uri)) {
/**
* If 'uri' isn't passed as parameter it reads $_GET['_url']
*/
PHALCON_CALL_METHOD(&real_uri, this_ptr, "getrewriteuri");
} else {
PHALCON_CPY_WRT(real_uri, uri);
}
PHALCON_OBS_VAR(processed);
phalcon_read_property_this(&processed, this_ptr, SL("_processed"), PH_NOISY TSRMLS_CC);
if (!zend_is_true(processed)) {
PHALCON_INIT_VAR(annotations_service);
PHALCON_OBS_VAR(handlers);
phalcon_read_property_this(&handlers, this_ptr, SL("_handlers"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(handlers) == IS_ARRAY) {
PHALCON_OBS_VAR(controller_suffix);
phalcon_read_property_this(&controller_suffix, this_ptr, SL("_controllerSuffix"), PH_NOISY TSRMLS_CC);
phalcon_is_iterable(handlers, &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) {
/**
* A prefix (if any) must be in position 0
*/
PHALCON_OBS_NVAR(prefix);
phalcon_array_fetch_long(&prefix, scope, 0, PH_NOISY);
if (Z_TYPE_P(prefix) == IS_STRING) {
if (!phalcon_start_with(real_uri, prefix, NULL)) {
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
}
if (Z_TYPE_P(annotations_service) != IS_OBJECT) {
PHALCON_OBS_NVAR(dependency_injector);
phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_router_exception_ce, "A dependency injection container is required to access the 'annotations' service");
return;
}
PHALCON_INIT_NVAR(service);
ZVAL_STRING(service, "annotations", 1);
PHALCON_CALL_METHOD(&annotations_service, dependency_injector, "getshared", service);
PHALCON_VERIFY_INTERFACE(annotations_service, phalcon_annotations_adapterinterface_ce);
}
/**
* The controller must be in position 1
*/
PHALCON_OBS_NVAR(handler);
phalcon_array_fetch_long(&handler, scope, 1, PH_NOISY);
if (phalcon_memnstr_str(handler, SL("\\"))) {
/**
* Extract the real class name from the namespaced class
*/
PHALCON_INIT_NVAR(controller_name);
phalcon_get_class_ns(controller_name, handler, 0 TSRMLS_CC);
/**
* Extract the namespace from the namespaced class
*/
PHALCON_INIT_NVAR(namespace_name);
phalcon_get_ns_class(namespace_name, handler, 0 TSRMLS_CC);
} else {
PHALCON_CPY_WRT(controller_name, handler);
PHALCON_INIT_NVAR(namespace_name);
}
phalcon_update_property_null(this_ptr, SL("_routePrefix") TSRMLS_CC);
/**
* Check if the scope has a module associated
*/
if (phalcon_array_isset_long(scope, 2)) {
PHALCON_OBS_NVAR(module_name);
phalcon_array_fetch_long(&module_name, scope, 2, PH_NOISY);
} else {
PHALCON_INIT_NVAR(module_name);
}
PHALCON_INIT_NVAR(suffixed);
PHALCON_CONCAT_VV(suffixed, handler, controller_suffix);
/**
* Get the annotations from the class
*/
PHALCON_CALL_METHOD(&handler_annotations, annotations_service, "get", suffixed);
/**
* Process class annotations
*/
PHALCON_CALL_METHOD(&class_annotations, handler_annotations, "getclassannotations");
if (Z_TYPE_P(class_annotations) == IS_OBJECT) {
/**
* Process class annotations
*/
PHALCON_CALL_METHOD(&annotations, class_annotations, "getannotations");
if (Z_TYPE_P(annotations) == IS_ARRAY) {
phalcon_is_iterable(annotations, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HVALUE(annotation);
PHALCON_CALL_METHOD(NULL, this_ptr, "processcontrollerannotation", controller_name, annotation);
zend_hash_move_forward_ex(ah1, &hp1);
}
}
}
/**
* Process method annotations
*/
PHALCON_CALL_METHOD(&method_annotations, handler_annotations, "getmethodsannotations");
if (Z_TYPE_P(method_annotations) == IS_ARRAY) {
phalcon_is_iterable(method_annotations, &ah2, &hp2, 0, 0);
while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) {
PHALCON_GET_HKEY(method, ah2, hp2);
PHALCON_GET_HVALUE(collection);
if (Z_TYPE_P(collection) == IS_OBJECT) {
PHALCON_CALL_METHOD(&annotations, collection, "getannotations");
phalcon_is_iterable(annotations, &ah3, &hp3, 0, 0);
while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) {
PHALCON_GET_HVALUE(annotation);
PHALCON_CALL_METHOD(NULL, this_ptr, "processactionannotation", module_name, namespace_name, controller_name, method, annotation);
zend_hash_move_forward_ex(ah3, &hp3);
}
}
zend_hash_move_forward_ex(ah2, &hp2);
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
}
phalcon_update_property_bool(this_ptr, SL("_processed"), 1 TSRMLS_CC);
}
/**
* Call the parent handle method()
*/
PHALCON_CALL_PARENT(NULL, phalcon_mvc_router_annotations_ce, this_ptr, "handle", real_uri);
PHALCON_MM_RESTORE();
}
/**
* 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_Stream, buildBody){
zval *stream, *header, *data, *file, *username, *password, *authtype, *digest, *method, *entity_body;
zval *key = NULL, *value = NULL, *realm, *qop, *nonce, *nc, *cnonce, *qoc, *ha1 = NULL, *path = NULL, *md5_entity_body = NULL, *ha2 = NULL;
zval *http, *option = NULL, *body, *headers = NULL, *uniqid = NULL, *boundary;
zval *path_parts = NULL, *filename, *basename, *filedata = NULL, *tmp = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
stream = phalcon_fetch_nproperty_this(this_ptr, SL("_stream"), PH_NOISY TSRMLS_CC);
header = phalcon_fetch_nproperty_this(this_ptr, SL("_header"), PH_NOISY TSRMLS_CC);
data = phalcon_fetch_nproperty_this(this_ptr, SL("_data"), PH_NOISY TSRMLS_CC);
file = phalcon_fetch_nproperty_this(this_ptr, SL("_file"), PH_NOISY TSRMLS_CC);
username = phalcon_fetch_nproperty_this(this_ptr, SL("_username"), PH_NOISY TSRMLS_CC);
password = phalcon_fetch_nproperty_this(this_ptr, SL("_password"), PH_NOISY TSRMLS_CC);
authtype = phalcon_fetch_nproperty_this(this_ptr, SL("_authtype"), PH_NOISY TSRMLS_CC);
digest = phalcon_fetch_nproperty_this(this_ptr, SL("_digest"), PH_NOISY TSRMLS_CC);
method = phalcon_fetch_nproperty_this(this_ptr, SL("_method"), PH_NOISY TSRMLS_CC);
entity_body = phalcon_fetch_nproperty_this(this_ptr, SL("_entity_body"), PH_NOISY TSRMLS_CC);
if (PHALCON_IS_NOT_EMPTY(username)) {
if (PHALCON_IS_STRING(authtype, "basic")) {
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Authorization", 1);
PHALCON_INIT_NVAR(value);
PHALCON_CONCAT_SVSV(value, "Basic ", username, ":", password);
PHALCON_CALL_METHOD(NULL, header, "set", key, value);
} else if (PHALCON_IS_STRING(authtype, "digest") && PHALCON_IS_NOT_EMPTY(digest)) {
if (phalcon_array_isset_string_fetch(&realm, digest, SS("realm"))) {
PHALCON_INIT_VAR(realm);
ZVAL_NULL(realm);
}
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSVSV(tmp, username, ":", realm, ":", password);
PHALCON_CALL_FUNCTION(&ha1, "md5", tmp);
if (!phalcon_array_isset_string_fetch(&qop, digest, SS("qop"))) {
PHALCON_INIT_VAR(qop);
ZVAL_NULL(qop);
}
if (PHALCON_IS_EMPTY(qop) || phalcon_memnstr_str(qop, SL("auth"))) {
PHALCON_CALL_SELF(&path, "getpath");
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSV(tmp, method, ":", path);
PHALCON_CALL_FUNCTION(&ha2, "md5", tmp);
} else if (phalcon_memnstr_str(qop, SL("auth-int"))) {
PHALCON_CALL_SELF(&path, "getpath");
PHALCON_CALL_FUNCTION(&md5_entity_body, "md5", entity_body);
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSVSV(tmp, method, ":", path, ":", md5_entity_body);
PHALCON_CALL_FUNCTION(&ha2, "md5", tmp);
}
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Authorization", 1);
if (phalcon_array_isset_string_fetch(&nonce, digest, SS("nonce"))) {
PHALCON_INIT_VAR(nonce);
ZVAL_NULL(nonce);
}
if (PHALCON_IS_EMPTY(qop)) {
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSVSV(tmp, ha1, ":", nonce, ":", ha2);
PHALCON_CALL_FUNCTION(&value, "md5", tmp);
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_SV(tmp, "Digest ", value);
PHALCON_CALL_METHOD(NULL, header, "set", key, tmp);
} else {
if (phalcon_array_isset_string_fetch(&nc, digest, SS("nc"))) {
PHALCON_INIT_VAR(nc);
ZVAL_NULL(nc);
}
if (phalcon_array_isset_string_fetch(&cnonce, digest, SS("cnonce"))) {
PHALCON_INIT_VAR(cnonce);
ZVAL_NULL(cnonce);
}
if (phalcon_array_isset_string_fetch(&qoc, digest, SS("qoc"))) {
PHALCON_INIT_VAR(qoc);
ZVAL_NULL(qoc);
}
if (phalcon_array_isset_string_fetch(&qoc, digest, SS("qoc"))) {
PHALCON_INIT_VAR(qoc);
ZVAL_NULL(qoc);
}
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSVSVS(tmp, ha1, ":", nonce, ":", nc, ":");
PHALCON_SCONCAT_VSVSV(tmp, cnonce, ":", qoc, ":", ha2);
PHALCON_CALL_FUNCTION(&value, "md5", tmp);
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_SV(tmp, "Digest ", value);
PHALCON_CALL_METHOD(NULL, header, "set", key, tmp);
}
}
}
PHALCON_INIT_VAR(http);
ZVAL_STRING(http, "http", 1);
PHALCON_CALL_FUNCTION(&uniqid, "uniqid");
PHALCON_INIT_VAR(boundary);
PHALCON_CONCAT_SV(boundary, "--------------", uniqid);
PHALCON_INIT_VAR(body);
if (PHALCON_IS_NOT_EMPTY(data) && Z_TYPE_P(data) == IS_STRING){
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Content-Type", 1);
PHALCON_INIT_NVAR(value);
ZVAL_STRING(value, "application/x-www-form-urlencoded", 1);
PHALCON_CALL_METHOD(NULL, header, "set", key, value);
PHALCON_INIT_NVAR(option);
ZVAL_LONG(option, PHALCON_HTTP_CLIENT_HEADER_BUILD_FIELDS);
PHALCON_CALL_METHOD(&headers, header, "build", option);
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "header", 1);
PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, headers);
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "content", 1);
PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, data);
RETURN_MM();
}
if (Z_TYPE_P(data) == IS_ARRAY) {
phalcon_is_iterable(data, &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_SCONCAT_SVS(body, "--", boundary, "\r\n");
PHALCON_SCONCAT_SVSVS(body, "Content-Disposition: form-data; name=\"", key, "\"\r\n\r\n", value, "\r\n");
zend_hash_move_forward_ex(ah0, &hp0);
}
}
if (PHALCON_IS_NOT_EMPTY(file)) {
PHALCON_CALL_FUNCTION(&path_parts, "pathinfo", file);
if (phalcon_array_isset_string_fetch(&filename, path_parts, SS("filename")) && phalcon_array_isset_string_fetch(&basename, path_parts, SS("basename"))) {
PHALCON_CALL_FUNCTION(&filedata, "file_get_contents", file);
PHALCON_SCONCAT_SVS(body, "--", boundary, "\r\n");
PHALCON_SCONCAT_SVSVS(body, "Content-Disposition: form-data; name=\"", filename, "\"; filename=\"", basename, "\"\r\n");
PHALCON_SCONCAT_SVS(body, "Content-Type: application/octet-stream\r\n\r\n", filedata, "\r\n");
}
}
if (!PHALCON_IS_EMPTY(body)) {
PHALCON_SCONCAT_SVS(body, "--", boundary, "--\r\n");
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Content-Type", 1);
PHALCON_INIT_NVAR(value);
PHALCON_CONCAT_SV(value, "multipart/form-data; boundary=", boundary);
PHALCON_CALL_METHOD(NULL, header, "set", key, value);
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Content-Length", 1);
PHALCON_INIT_NVAR(value);
ZVAL_LONG(value, Z_STRLEN_P(body));
PHALCON_CALL_METHOD(NULL, header, "set", key, value);
PHALCON_INIT_NVAR(option);
ZVAL_LONG(option, PHALCON_HTTP_CLIENT_HEADER_BUILD_FIELDS);
PHALCON_CALL_METHOD(&headers, header, "build", option);
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "header", 1);
PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, headers);
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "content", 1);
PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, body);
}
PHALCON_MM_RESTORE();
}
/**
* The meta-data is obtained by reading the column descriptions from the database information schema
*
* @param Phalcon\Mvc\ModelInterface $model
* @param Phalcon\DiInterface $dependencyInjector
* @return array
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Strategy_Annotations, getMetaData){
zval *model, *dependency_injector, *service;
zval *annotations, *class_name, *reflection;
zval *exception_message = NULL, *properties_annotations;
zval *attributes, *primary_keys, *non_primary_keys;
zval *numeric_typed, *not_null, *field_types;
zval *field_bind_types, *automatic_default;
zval *identity_field = NULL, *column_annot_name;
zval *primary_annot_name, *id_annot_name;
zval *column_type_name, *column_nullable_name;
zval *prop_annotations = NULL, *property = NULL, *has_annotation = NULL;
zval *column_annotation = NULL, *feature = NULL, *model_metadata;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &model, &dependency_injector);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "The dependency injector is invalid");
return;
}
PHALCON_INIT_VAR(service);
ZVAL_STRING(service, "annotations", 1);
PHALCON_INIT_VAR(annotations);
phalcon_call_method_p1(annotations, dependency_injector, "get", service);
PHALCON_INIT_VAR(class_name);
phalcon_get_class(class_name, model, 0 TSRMLS_CC);
PHALCON_INIT_VAR(reflection);
phalcon_call_method_p1(reflection, annotations, "get", class_name);
if (Z_TYPE_P(reflection) != IS_OBJECT) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SV(exception_message, "No annotations were found in class ", class_name);
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message);
return;
}
/**
* Get the properties defined in
*/
PHALCON_INIT_VAR(properties_annotations);
phalcon_call_method(properties_annotations, reflection, "getpropertiesannotations");
if (!phalcon_fast_count_ev(properties_annotations TSRMLS_CC)) {
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SV(exception_message, "No properties with annotations were found in class ", class_name);
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message);
return;
}
/**
* Initialize meta-data
*/
PHALCON_INIT_VAR(attributes);
array_init(attributes);
PHALCON_INIT_VAR(primary_keys);
array_init(primary_keys);
PHALCON_INIT_VAR(non_primary_keys);
array_init(non_primary_keys);
PHALCON_INIT_VAR(numeric_typed);
array_init(numeric_typed);
PHALCON_INIT_VAR(not_null);
array_init(not_null);
PHALCON_INIT_VAR(field_types);
array_init(field_types);
PHALCON_INIT_VAR(field_bind_types);
array_init(field_bind_types);
PHALCON_INIT_VAR(automatic_default);
array_init(automatic_default);
PHALCON_INIT_VAR(identity_field);
ZVAL_BOOL(identity_field, 0);
PHALCON_INIT_VAR(column_annot_name);
ZVAL_STRING(column_annot_name, "Column", 1);
PHALCON_INIT_VAR(primary_annot_name);
ZVAL_STRING(primary_annot_name, "Primary", 1);
PHALCON_INIT_VAR(id_annot_name);
ZVAL_STRING(id_annot_name, "Identity", 1);
PHALCON_INIT_VAR(column_type_name);
ZVAL_STRING(column_type_name, "type", 1);
PHALCON_INIT_VAR(column_nullable_name);
ZVAL_STRING(column_nullable_name, "nullable", 1);
phalcon_is_iterable(properties_annotations, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(property, ah0, hp0);
PHALCON_GET_HVALUE(prop_annotations);
/**
* All columns marked with the 'Column' annotation are considered columns
*/
PHALCON_INIT_NVAR(has_annotation);
phalcon_call_method_p1(has_annotation, prop_annotations, "has", column_annot_name);
if (!zend_is_true(has_annotation)) {
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
/**
* Fetch the 'column' annotation
*/
PHALCON_INIT_NVAR(column_annotation);
phalcon_call_method_p1(column_annotation, prop_annotations, "get", column_annot_name);
/**
* Check if annotation has the 'type' named parameter
*/
PHALCON_INIT_NVAR(feature);
phalcon_call_method_p1(feature, column_annotation, "getnamedparameter", column_type_name);
if (PHALCON_IS_STRING(feature, "integer")) {
phalcon_array_update_zval_long(&field_types, property, 0, PH_SEPARATE);
phalcon_array_update_zval_long(&field_bind_types, property, 1, PH_SEPARATE);
phalcon_array_update_zval_bool(&numeric_typed, property, 1, PH_SEPARATE);
} else {
if (PHALCON_IS_STRING(feature, "decimal")) {
phalcon_array_update_zval_long(&field_types, property, 3, PH_SEPARATE);
phalcon_array_update_zval_long(&field_bind_types, property, 32, PH_SEPARATE);
phalcon_array_update_zval_bool(&numeric_typed, property, 1, PH_SEPARATE);
} else {
if (PHALCON_IS_STRING(feature, "boolean")) {
phalcon_array_update_zval_long(&field_types, property, 8, PH_SEPARATE);
phalcon_array_update_zval_long(&field_bind_types, property, 5, PH_SEPARATE);
} else {
if (PHALCON_IS_STRING(feature, "date")) {
phalcon_array_update_zval_long(&field_types, property, 1, PH_SEPARATE);
} else {
/**
* By default all columns are varchar/string
*/
phalcon_array_update_zval_long(&field_types, property, 2, PH_SEPARATE);
}
phalcon_array_update_zval_long(&field_bind_types, property, 2, PH_SEPARATE);
}
}
}
/**
* All columns marked with the 'Primary' annotation are considered primary keys
*/
PHALCON_INIT_NVAR(has_annotation);
phalcon_call_method_p1(has_annotation, prop_annotations, "has", primary_annot_name);
if (zend_is_true(has_annotation)) {
phalcon_array_append(&primary_keys, property, PH_SEPARATE);
} else {
phalcon_array_append(&non_primary_keys, property, PH_SEPARATE);
}
/**
* All columns marked with the 'Primary' annotation are considered primary keys
*/
PHALCON_INIT_NVAR(has_annotation);
phalcon_call_method_p1(has_annotation, prop_annotations, "has", id_annot_name);
if (zend_is_true(has_annotation)) {
PHALCON_CPY_WRT(identity_field, property);
}
/**
* Check if the column
*/
PHALCON_INIT_NVAR(feature);
phalcon_call_method_p1(feature, column_annotation, "getnamedparameter", column_nullable_name);
if (!zend_is_true(feature)) {
phalcon_array_append(¬_null, property, PH_SEPARATE);
}
phalcon_array_append(&attributes, property, PH_SEPARATE);
zend_hash_move_forward_ex(ah0, &hp0);
}
/**
* Create an array using the MODELS_* constants as indexes
*/
PHALCON_INIT_VAR(model_metadata);
array_init(model_metadata);
phalcon_array_update_long(&model_metadata, 0, &attributes, PH_COPY | PH_SEPARATE);
phalcon_array_update_long(&model_metadata, 1, &primary_keys, PH_COPY | PH_SEPARATE);
phalcon_array_update_long(&model_metadata, 2, &non_primary_keys, PH_COPY | PH_SEPARATE);
phalcon_array_update_long(&model_metadata, 3, ¬_null, PH_COPY | PH_SEPARATE);
phalcon_array_update_long(&model_metadata, 4, &field_types, PH_COPY | PH_SEPARATE);
phalcon_array_update_long(&model_metadata, 5, &numeric_typed, PH_COPY | PH_SEPARATE);
phalcon_array_update_long(&model_metadata, 8, &identity_field, PH_COPY | PH_SEPARATE);
phalcon_array_update_long(&model_metadata, 9, &field_bind_types, PH_COPY | PH_SEPARATE);
phalcon_array_update_long(&model_metadata, 10, &automatic_default, PH_COPY | PH_SEPARATE);
phalcon_array_update_long(&model_metadata, 11, &automatic_default, PH_COPY | PH_SEPARATE);
RETURN_CTOR(model_metadata);
}
PHP_METHOD(Phalcon_Http_Client_Adapter_Curl, sendInternal){
zval *uri = NULL, *url = NULL, *method, *useragent, *data, *type, *files, *timeout, *curl, *username, *password, *authtype;
zval *file = NULL, *body, *uniqid = NULL, *boundary, *key = NULL, *value = NULL;
zval *path_parts = NULL, *filename, *basename, *filedata = NULL;
zval *constant, *header, *headers = NULL;
zval *content = NULL, *errorno = NULL, *error = NULL, *headersize = NULL, *httpcode = NULL, *headerstr, *bodystr, *response, *tmp = NULL;
zend_class_entry *curlfile_ce;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
PHALCON_MM_GROW();
PHALCON_CALL_SELF(&uri, "geturi");
PHALCON_CALL_METHOD(&url, uri, "build");
method = phalcon_fetch_nproperty_this(this_ptr, SL("_method"), PH_NOISY TSRMLS_CC);
useragent = phalcon_fetch_nproperty_this(this_ptr, SL("_useragent"), PH_NOISY TSRMLS_CC);
data = phalcon_fetch_nproperty_this(this_ptr, SL("_data"), PH_NOISY TSRMLS_CC);
type = phalcon_fetch_nproperty_this(this_ptr, SL("_type"), PH_NOISY TSRMLS_CC);
files = phalcon_fetch_nproperty_this(this_ptr, SL("_files"), PH_NOISY TSRMLS_CC);
timeout = phalcon_fetch_nproperty_this(this_ptr, SL("_timeout"), PH_NOISY TSRMLS_CC);
curl = phalcon_fetch_nproperty_this(this_ptr, SL("_curl"), PH_NOISY TSRMLS_CC);
username = phalcon_fetch_nproperty_this(this_ptr, SL("_username"), PH_NOISY TSRMLS_CC);
password = phalcon_fetch_nproperty_this(this_ptr, SL("_password"), PH_NOISY TSRMLS_CC);
authtype = phalcon_fetch_nproperty_this(this_ptr, SL("_authtype"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(constant);
if (!zend_get_constant(SL("CURLOPT_URL"), constant TSRMLS_CC)) {
RETURN_MM_FALSE;
}
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, url);
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_CONNECTTIMEOUT"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, timeout);
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_TIMEOUT"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, timeout);
}
PHALCON_INIT_NVAR(constant);
if (PHALCON_IS_NOT_EMPTY(method) && zend_get_constant(SL("CURLOPT_CUSTOMREQUEST"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, method);
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_USERAGENT"), constant TSRMLS_CC) && PHALCON_IS_NOT_EMPTY(useragent)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, useragent);
}
header = phalcon_fetch_nproperty_this(this_ptr, SL("_header"), PH_NOISY TSRMLS_CC);
if (PHALCON_IS_NOT_EMPTY(username)) {
if (PHALCON_IS_STRING(authtype, "any")) {
PHALCON_INIT_NVAR(constant);
PHALCON_INIT_NVAR(tmp);
if (zend_get_constant(SL("CURLOPT_HTTPAUTH"), constant TSRMLS_CC) && zend_get_constant(SL("CURLAUTH_ANY"), tmp TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_USERPWD"), constant TSRMLS_CC)) {
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSV(tmp, username, ":", password);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
}
}
} else if (PHALCON_IS_STRING(authtype, "basic")) {
PHALCON_INIT_NVAR(constant);
PHALCON_INIT_NVAR(tmp);
if (zend_get_constant(SL("CURLOPT_HTTPAUTH"), constant TSRMLS_CC) && zend_get_constant(SL("CURLAUTH_BASIC"), tmp TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_USERPWD"), constant TSRMLS_CC)) {
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSV(tmp, username, ":", password);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
}
}
} else if (PHALCON_IS_STRING(authtype, "digest")) {
PHALCON_INIT_NVAR(constant);
PHALCON_INIT_NVAR(tmp);
if (zend_get_constant(SL("CURLOPT_HTTPAUTH"), constant TSRMLS_CC) && zend_get_constant(SL("CURLAUTH_DIGEST"), tmp TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_USERPWD"), constant TSRMLS_CC)) {
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSV(tmp, username, ":", password);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
}
}
}
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_SAFE_UPLOAD"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, PHALCON_GLOBAL(z_true));
}
if (Z_TYPE_P(data) == IS_STRING && PHALCON_IS_NOT_EMPTY(data)) {
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Content-Type", 1);
if (PHALCON_IS_EMPTY(type)) {
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "application/x-www-form-urlencoded", 1);
}
PHALCON_CALL_METHOD(NULL, header, "set", key, type);
PHALCON_INIT_NVAR(constant);
zend_get_constant(SL("CURLOPT_POSTFIELDS"), constant TSRMLS_CC);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, data);
} else if (phalcon_class_exists(SL("CURLFile"), 0 TSRMLS_CC)) {
if (Z_TYPE_P(data) != IS_ARRAY) {
PHALCON_INIT_NVAR(data);
array_init(data);
}
if (Z_TYPE_P(files) == IS_ARRAY) {
phalcon_is_iterable(files, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(file);
if (PHALCON_IS_NOT_EMPTY(file)) {
curlfile_ce = zend_fetch_class(SL("CURLFile"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_INIT_NVAR(tmp);
object_init_ex(tmp, curlfile_ce);
PHALCON_CALL_METHOD(NULL, tmp, "__construct", file);
phalcon_array_append(&data, tmp, PH_COPY);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
}
PHALCON_INIT_NVAR(constant);
zend_get_constant(SL("CURLOPT_POSTFIELDS"), constant TSRMLS_CC);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, data);
} else {
PHALCON_CALL_FUNCTION(&uniqid, "uniqid");
PHALCON_INIT_VAR(boundary);
PHALCON_CONCAT_SV(boundary, "--------------", uniqid);
PHALCON_INIT_VAR(body);
if (Z_TYPE_P(data) == IS_ARRAY) {
phalcon_is_iterable(data, &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_SCONCAT_SVS(body, "--", boundary, "\r\n");
PHALCON_SCONCAT_SVSVS(body, "Content-Disposition: form-data; name=\"", key, "\"\r\n\r\n", value, "\r\n");
zend_hash_move_forward_ex(ah0, &hp0);
}
}
if (Z_TYPE_P(files) == IS_ARRAY) {
phalcon_is_iterable(files, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HVALUE(file);
if (PHALCON_IS_NOT_EMPTY(file)) {
PHALCON_CALL_FUNCTION(&path_parts, "pathinfo", file);
if (phalcon_array_isset_string_fetch(&filename, path_parts, SS("filename")) && phalcon_array_isset_string_fetch(&basename, path_parts, SS("basename"))) {
PHALCON_CALL_FUNCTION(&filedata, "file_get_contents", file);
PHALCON_SCONCAT_SVS(body, "--", boundary, "\r\n");
PHALCON_SCONCAT_SVSVS(body, "Content-Disposition: form-data; name=\"", filename, "\"; filename=\"", basename, "\"\r\n");
PHALCON_SCONCAT_SVS(body, "Content-Type: application/octet-stream\r\n\r\n", filedata, "\r\n");
}
}
zend_hash_move_forward_ex(ah1, &hp1);
}
}
if (!PHALCON_IS_EMPTY(body)) {
PHALCON_SCONCAT_SVS(body, "--", boundary, "--\r\n");
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Content-Type", 1);
PHALCON_INIT_NVAR(value);
PHALCON_CONCAT_SV(value, "multipart/form-data; boundary=", boundary);
PHALCON_CALL_METHOD(NULL, header, "set", key, value);
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Content-Length", 1);
PHALCON_INIT_NVAR(value);
ZVAL_LONG(value, Z_STRLEN_P(body));
PHALCON_CALL_METHOD(NULL, header, "set", key, value);
PHALCON_CALL_METHOD(&headers, header, "build");
PHALCON_INIT_NVAR(constant);
zend_get_constant(SL("CURLOPT_POSTFIELDS"), constant TSRMLS_CC);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, body);
PHALCON_INIT_NVAR(constant);
zend_get_constant(SL("CURLOPT_HTTPHEADER"), constant TSRMLS_CC);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, headers);
}
}
PHALCON_CALL_FUNCTION(&content, "curl_exec", curl);
PHALCON_CALL_FUNCTION(&errorno, "curl_errno", curl);
if (PHALCON_IS_TRUE(errorno)) {
PHALCON_CALL_FUNCTION(&error, "curl_error", curl);
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_http_client_exception_ce, error);
return;
}
PHALCON_INIT_VAR(response);
object_init_ex(response, phalcon_http_client_response_ce);
PHALCON_CALL_METHOD(NULL, response, "__construct");
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLINFO_HTTP_CODE"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(&httpcode, "curl_getinfo", curl, constant);
PHALCON_CALL_METHOD(NULL, response, "setstatuscode", httpcode);
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLINFO_HEADER_SIZE"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(&headersize, "curl_getinfo", curl, constant);
PHALCON_INIT_VAR(headerstr);
phalcon_substr(headerstr, content, 0 , Z_LVAL_P(headersize));
PHALCON_INIT_VAR(bodystr);
phalcon_substr(bodystr, content, Z_LVAL_P(headersize) , Z_STRLEN_P(content));
PHALCON_CALL_METHOD(NULL, response, "setheader", headerstr);
PHALCON_CALL_METHOD(NULL, response, "setbody", bodystr);
}
RETURN_CTOR(response);
}
PHP_METHOD(Phalcon_Http_Client_Header, build){
zval *flags = NULL, *messages, *status_code, *message = NULL, *version, *lines, *line = NULL;
zval *fields, *filed = NULL, *value = NULL, *join_filed;
HashTable *ah0;
HashPosition hp0;
zval **hd;
int f = 0;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, &flags);
if (flags) {
f = phalcon_get_intval(flags);
}
PHALCON_INIT_VAR(lines);
array_init(lines);
PHALCON_OBS_VAR(messages);
phalcon_read_static_property_ce(&messages, phalcon_http_client_header_ce, SL("_messages") TSRMLS_CC);
status_code = phalcon_fetch_nproperty_this(this_ptr, SL("_status_code"), PH_NOISY TSRMLS_CC);
if ((f & PHALCON_HTTP_CLIENT_HEADER_BUILD_STATUS) && phalcon_array_isset_fetch(&message, messages, status_code)) {
version = phalcon_fetch_nproperty_this(this_ptr, SL("_version "), PH_NOISY TSRMLS_CC);
PHALCON_INIT_NVAR(line);
PHALCON_CONCAT_SVS(line, "HTTP/", version, " ");
PHALCON_SCONCAT_VSV(line, status_code, " ", message);
phalcon_merge_append(lines, line);
}
fields = phalcon_fetch_nproperty_this(this_ptr, SL("_fields"), PH_NOISY TSRMLS_CC);
phalcon_is_iterable(fields, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(filed, ah0, hp0);
PHALCON_GET_HVALUE(value);
PHALCON_INIT_NVAR(line);
PHALCON_CONCAT_VSV(line, filed, ": ", value);
phalcon_merge_append(lines, line);
zend_hash_move_forward_ex(ah0, &hp0);
}
if (f & PHALCON_HTTP_CLIENT_HEADER_BUILD_FIELDS) {
PHALCON_INIT_VAR(join_filed);
phalcon_fast_join_str(join_filed, SL("\r\n"), lines TSRMLS_CC);
RETURN_CCTOR(join_filed);
}
RETURN_CCTOR(lines);
}
/**
* Check whether internal resource has rows to fetch
*
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, valid){
zval *type = NULL, *row = NULL, *underscore;
zval *empty_str, *active_row = NULL;
zval *dirty_state, *column = NULL, *alias = NULL, *source = NULL, *attributes = NULL;
zval *column_map = NULL, *row_model = NULL, *attribute = NULL, *column_alias = NULL;
zval *column_value = NULL;
zval *value = NULL, *sql_alias = NULL, *n_alias = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
int i_type, is_partial;
PHALCON_MM_GROW();
type = phalcon_fetch_nproperty_this(this_ptr, SL("_type"), PH_NOISY TSRMLS_CC);
i_type = (Z_TYPE_P(type) == IS_LONG) ? Z_LVAL_P(type) : phalcon_get_intval(type);
is_partial = (i_type == PHALCON_MVC_MODEL_RESULTSET_TYPE_PARTIAL);
type = NULL;
PHALCON_INIT_VAR(row);
if (is_partial) {
/**
* The result is bigger than 32 rows so it's retrieved one by one
*/
zval *result = phalcon_fetch_nproperty_this(this_ptr, SL("_result"), PH_NOISY TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(result)) {
PHALCON_CALL_METHOD(&row, result, "fetch", result);
} else {
ZVAL_FALSE(row);
}
} else {
/**
* The full rows are dumped in this_ptr->rows
*/
zval *rows = phalcon_fetch_nproperty_this(this_ptr, SL("_rows"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(rows) == IS_ARRAY) {
phalcon_array_get_current(row, rows);
if (Z_TYPE_P(row) == IS_OBJECT) {
zend_hash_move_forward(Z_ARRVAL_P(rows));
}
} else {
ZVAL_FALSE(row);
}
}
/**
* Valid records are arrays
*/
if (Z_TYPE_P(row) == IS_ARRAY || Z_TYPE_P(row) == IS_OBJECT) {
/**
* The result type=1 so we need to build every row
*/
if (is_partial) {
/**
* Get current hydration mode
*/
zval *hydrate_mode = phalcon_fetch_nproperty_this(this_ptr, SL("_hydrateMode"), PH_NOISY TSRMLS_CC);
zval *columns_types = phalcon_fetch_nproperty_this(this_ptr, SL("_columnTypes"), PH_NOISY TSRMLS_CC);
int i_hydrate_mode = phalcon_get_intval(hydrate_mode);
PHALCON_INIT_VAR(underscore);
ZVAL_STRING(underscore, "_", 1);
PHALCON_INIT_VAR(empty_str);
ZVAL_EMPTY_STRING(empty_str);
/**
* Each row in a complex result is a Phalcon\Mvc\Model\Row instance
*/
PHALCON_INIT_VAR(active_row);
switch (i_hydrate_mode) {
case 0:
object_init_ex(active_row, phalcon_mvc_model_row_ce);
break;
case 1:
array_init(active_row);
break;
case 2:
default:
object_init(active_row);
break;
}
/**
* Create every record according to the column types
*/
/**
* Set records as dirty state PERSISTENT by default
*/
PHALCON_INIT_VAR(dirty_state);
ZVAL_LONG(dirty_state, 0);
phalcon_is_iterable(columns_types, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(alias, ah0, hp0);
PHALCON_GET_HVALUE(column);
PHALCON_OBS_NVAR(type);
phalcon_array_fetch_string(&type, column, SL("type"), PH_NOISY);
if (PHALCON_IS_STRING(type, "object")) {
/**
* Object columns are assigned column by column
*/
PHALCON_OBS_NVAR(source);
phalcon_array_fetch_string(&source, column, SL("column"), PH_NOISY);
PHALCON_OBS_NVAR(attributes);
phalcon_array_fetch_string(&attributes, column, SL("attributes"), PH_NOISY);
PHALCON_OBS_NVAR(column_map);
phalcon_array_fetch_string(&column_map, column, SL("columnMap"), PH_NOISY);
/**
* Assign the values from the _source_attribute notation to its real column name
*/
PHALCON_INIT_NVAR(row_model);
array_init(row_model);
phalcon_is_iterable(attributes, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HVALUE(attribute);
/**
* Columns are supposed to be in the form _table_field
*/
PHALCON_INIT_NVAR(column_alias);
PHALCON_CONCAT_VVVV(column_alias, underscore, source, underscore, attribute);
PHALCON_OBS_NVAR(column_value);
phalcon_array_fetch(&column_value, row, column_alias, PH_NOISY);
phalcon_array_update_zval(&row_model, attribute, column_value, PH_COPY | PH_SEPARATE);
zend_hash_move_forward_ex(ah1, &hp1);
}
/**
* Generate the column value according to the hydration type
*/
switch (phalcon_get_intval(hydrate_mode)) {
case 0: {
zval *keep_snapshots, *instance;
/**
* Check if the resultset must keep snapshots
*/
if (!phalcon_array_isset_string_fetch(&keep_snapshots, column, SS("keepSnapshots"))) {
keep_snapshots = PHALCON_GLOBAL(z_false);
}
/**
* Get the base instance
*/
if (!phalcon_array_isset_string_fetch(&instance, column, SS("instance"))) {
php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Undefined index: instance");
instance = PHALCON_GLOBAL(z_null);
}
/**
* Assign the values to the attributes using a column map
*/
PHALCON_CALL_CE_STATIC(&value, phalcon_mvc_model_ce, "cloneresultmap", instance, row_model, column_map, dirty_state, keep_snapshots);
break;
}
default:
/**
* Other kinds of hydrations
*/
PHALCON_CALL_CE_STATIC(&value, phalcon_mvc_model_ce, "cloneresultmaphydrate", row_model, column_map, hydrate_mode);
break;
}
/**
* The complete object is assigned to an attribute with the name of the alias or
* the model name
*/
PHALCON_OBS_NVAR(attribute);
if (phalcon_array_isset_string(column, SS("balias"))) {
phalcon_array_fetch_string(&attribute, column, SL("balias"), PH_NOISY);
}
} else {
/**
* Scalar columns are simply assigned to the result object
*/
if (phalcon_array_isset_string(column, SS("sqlAlias"))) {
PHALCON_OBS_NVAR(sql_alias);
phalcon_array_fetch_string(&sql_alias, column, SL("sqlAlias"), PH_NOISY);
PHALCON_OBS_NVAR(value);
phalcon_array_fetch(&value, row, sql_alias, PH_NOISY);
} else {
PHALCON_OBS_NVAR(value);
if (phalcon_array_isset(row, alias)) {
phalcon_array_fetch(&value, row, alias, PH_NOISY);
}
}
/**
* If a 'balias' is defined is not an unnamed scalar
*/
if (phalcon_array_isset_string(column, SS("balias"))) {
PHALCON_CPY_WRT(attribute, alias);
} else {
PHALCON_INIT_NVAR(n_alias);
phalcon_fast_str_replace(n_alias, underscore, empty_str, alias);
PHALCON_CPY_WRT(attribute, n_alias);
}
assert(attribute != NULL);
}
/**
* Assign the instance according to the hydration type
*/
if (unlikely(!attribute)) {
zend_throw_exception_ex(phalcon_mvc_model_exception_ce, 0 TSRMLS_CC, "Unexpected inconsistency: attribute is NULL");
RETURN_MM();
}
switch (phalcon_get_intval(hydrate_mode)) {
case 1:
phalcon_array_update_zval(&active_row, attribute, value, PH_COPY | PH_SEPARATE);
break;
default:
phalcon_update_property_zval_zval(active_row, attribute, value TSRMLS_CC);
break;
}
zend_hash_move_forward_ex(ah0, &hp0);
}
/**
* Store the generated row in this_ptr->activeRow to be retrieved by 'current'
*/
phalcon_update_property_this(this_ptr, SL("_activeRow"), active_row TSRMLS_CC);
} else {
/**
* The row is already built so we just assign it to the activeRow
*/
phalcon_update_property_this(this_ptr, SL("_activeRow"), row TSRMLS_CC);
}
RETURN_MM_TRUE;
}
/**
* There are no results to retrieve so we update this_ptr->activeRow as false
*/
phalcon_update_property_bool(this_ptr, SL("_activeRow"), 0 TSRMLS_CC);
RETURN_MM_FALSE;
}
/**
* 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) {
/**
* 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;
}
/**
* 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, *left_part = NULL;
zval *right_part = 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 TSRMLS_CC) != 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) {
phalcon_array_update_zval(&config, section, &directives, 0 TSRMLS_CC);
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(".") TSRMLS_CC)) {
PHALCON_INIT_NVAR(directive_parts);
phalcon_fast_explode_str(directive_parts, SL("."), key TSRMLS_CC);
PHALCON_OBS_NVAR(left_part);
phalcon_array_fetch_long(&left_part, directive_parts, 0, PH_NOISY_CC);
PHALCON_OBS_NVAR(right_part);
phalcon_array_fetch_long(&right_part, directive_parts, 1, PH_NOISY_CC);
phalcon_array_update_zval_zval_zval_multi_3(&config, section, left_part, right_part, &value, 0 TSRMLS_CC);
} else {
phalcon_array_update_multi_2(&config, section, key, &value, 0 TSRMLS_CC);
}
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();
}