/** * Gets a session variable from an application context * * @param string $index * @param mixed $defaultValue * @return mixed */ PHP_METHOD(Phalcon_Session_Adapter, get){ zval *index, *default_value = NULL, *unique_id, *key, *_SESSION; zval *value; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &index, &default_value) == FAILURE) { RETURN_MM_NULL(); } if (!default_value) { PHALCON_INIT_VAR(default_value); } PHALCON_OBS_VAR(unique_id); phalcon_read_property(&unique_id, this_ptr, SL("_uniqueId"), PH_NOISY_CC); PHALCON_INIT_VAR(key); PHALCON_CONCAT_VV(key, unique_id, index); phalcon_get_global(&_SESSION, SS("_SESSION") TSRMLS_CC); if (phalcon_array_isset(_SESSION, key)) { PHALCON_OBS_VAR(value); phalcon_array_fetch(&value, _SESSION, key, PH_NOISY_CC); if (PHALCON_IS_NOT_EMPTY(value)) { RETURN_CCTOR(value); } } RETURN_CCTOR(default_value); }
/** * Gets the column name in MySQL * * @param Phalcon\Db\ColumnInterface $column * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, getColumnDefinition){ zval *column, size = {}, column_type = {}, column_sql = {}, type_values = {}, slash = {}, *value, value_cslashes = {}, is_unsigned = {}, scale = {}, name = {}; int c, i = 0; phalcon_fetch_params(0, 1, 0, &column); PHALCON_VERIFY_INTERFACE_EX(column, phalcon_db_columninterface_ce, phalcon_db_exception_ce, 0); PHALCON_CALL_METHODW(&size, column, "getsize"); PHALCON_CALL_METHODW(&column_type, column, "gettype"); if (Z_TYPE(column_type) == IS_STRING) { PHALCON_CPY_WRT(&column_sql, &column_type); PHALCON_CALL_METHODW(&type_values, column, "gettypevalues"); if (PHALCON_IS_NOT_EMPTY(&type_values)) { ZVAL_STRING(&slash, "\""); if (Z_TYPE(type_values) == IS_ARRAY) { c = phalcon_fast_count_int(&type_values); phalcon_concat_self_str(&column_sql, SL("(")); ZEND_HASH_FOREACH_VAL(Z_ARRVAL(type_values), value) { i++; PHALCON_CALL_FUNCTIONW(&value_cslashes, "addcslashes", value, &slash); if (i < c) { PHALCON_SCONCAT_SVS(&column_sql, "\"", &value_cslashes, "\", "); } else { PHALCON_SCONCAT_SVS(&column_sql, "\"", &value_cslashes, "\""); } } ZEND_HASH_FOREACH_END();
/** * Returns uri * * @return string */ PHP_METHOD(Phalcon_Http_Uri, build){ zval *parts, *uri, *scheme, *host, *user, *pass, *port, *path, *query, *fragment, *tmp = NULL; PHALCON_MM_GROW(); parts = phalcon_read_property(getThis(), SL("_parts"), PH_NOISY); PHALCON_INIT_VAR(uri); if (phalcon_array_isset_str_fetch(&scheme, parts, SL("scheme")) && PHALCON_IS_NOT_EMPTY(scheme)) { if (phalcon_array_isset_str_fetch(&host, parts, SL("host")) && PHALCON_IS_NOT_EMPTY(host)) { if (phalcon_array_isset_str_fetch(&user, parts, SL("user")) && PHALCON_IS_NOT_EMPTY(user)) { if (phalcon_array_isset_str_fetch(&pass, parts, SL("pass")) && PHALCON_IS_NOT_EMPTY(pass)) { PHALCON_CONCAT_VSVSVSV(uri, scheme, "://", user, ":", pass, "@", host); } else { PHALCON_CONCAT_VSVSV(uri, scheme, "://", user, "@", host); } } else { PHALCON_CONCAT_VSV(uri, scheme, "://", host); } } else { PHALCON_CONCAT_VS(uri, scheme, ":"); } } if (phalcon_array_isset_str_fetch(&port, parts, SL("port")) && PHALCON_IS_NOT_EMPTY(port)) { PHALCON_SCONCAT_SV(uri, ":", port); } if (phalcon_array_isset_str_fetch(&path, parts, SL("path")) && PHALCON_IS_NOT_EMPTY(path)) { if (!phalcon_start_with_str(path, SL("/"))) { PHALCON_SCONCAT_SV(uri, "/", path); } else { PHALCON_INIT_NVAR(tmp); PHALCON_CONCAT_VV(tmp, uri, path); PHALCON_CPY_WRT(uri, tmp); } } if (phalcon_array_isset_str_fetch(&query, parts, SL("query")) && PHALCON_IS_NOT_EMPTY(query)) { PHALCON_INIT_NVAR(tmp); phalcon_http_build_query(tmp, query, "&"); PHALCON_SCONCAT_SV(uri, "?", tmp); } if (phalcon_array_isset_str_fetch(&fragment, parts, SL("fragment")) && PHALCON_IS_NOT_EMPTY(fragment)) { PHALCON_SCONCAT_SV(uri, "#", fragment); } RETURN_CTOR(uri); }
/** * 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 uri * * @return string */ PHP_METHOD(Phalcon_Http_Uri, build) { zval parts = {}, uri = {}, scheme = {}, host = {}, user = {}, pass = {}, port = {}, path = {}, query = {}, fragment = {}, tmp = {}; phalcon_read_property(&parts, getThis(), SL("_parts"), PH_NOISY); if (phalcon_array_isset_fetch_str(&scheme, &parts, SL("scheme")) && PHALCON_IS_NOT_EMPTY(&scheme)) { if (phalcon_array_isset_fetch_str(&host, &parts, SL("host")) && PHALCON_IS_NOT_EMPTY(&host)) { if (phalcon_array_isset_fetch_str(&user, &parts, SL("user")) && PHALCON_IS_NOT_EMPTY(&user)) { if (phalcon_array_isset_fetch_str(&pass, &parts, SL("pass")) && PHALCON_IS_NOT_EMPTY(&pass)) { PHALCON_CONCAT_VSVSVSV(&uri, &scheme, "://", &user, ":", &pass, "@", &host); } else { PHALCON_CONCAT_VSVSV(&uri, &scheme, "://", &user, "@", &host); } } else { PHALCON_CONCAT_VSV(&uri, &scheme, "://", &host); } } else { PHALCON_CONCAT_VS(&uri, &scheme, ":"); } } if (phalcon_array_isset_fetch_str(&port, &parts, SL("port")) && PHALCON_IS_NOT_EMPTY(&port)) { PHALCON_SCONCAT_SV(&uri, ":", &port); } if (phalcon_array_isset_fetch_str(&path, &parts, SL("path")) && PHALCON_IS_NOT_EMPTY(&path)) { if (!phalcon_start_with_str(&path, SL("/"))) { PHALCON_SCONCAT_SV(&uri, "/", &path); } else { PHALCON_SCONCAT(&uri, &path); } } if (phalcon_array_isset_fetch_str(&query, &parts, SL("query")) && PHALCON_IS_NOT_EMPTY(&query)) { phalcon_http_build_query(&tmp, &query, "&"); PHALCON_SCONCAT_SV(&uri, "?", &tmp); } if (phalcon_array_isset_fetch_str(&fragment, &parts, SL("fragment")) && PHALCON_IS_NOT_EMPTY(&fragment)) { PHALCON_SCONCAT_SV(&uri, "#", &fragment); } RETURN_CTORW(&uri); }
/** * Obtains a value from the session bag optionally setting a default value * *<code> * echo $user->get('name', 'Kimbra'); *</code> * * @param string $property * @param string $defaultValue * @return mixed */ PHP_METHOD(Phalcon_Session_Bag, get){ zval *property, *default_value = NULL, *initalized; zval *data, *value; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &property, &default_value) == FAILURE) { RETURN_MM_NULL(); } if (!default_value) { PHALCON_INIT_VAR(default_value); } /** * Check first if the bag is initialized */ PHALCON_OBS_VAR(initalized); phalcon_read_property(&initalized, this_ptr, SL("_initalized"), PH_NOISY_CC); if (PHALCON_IS_FALSE(initalized)) { PHALCON_CALL_METHOD_NORETURN(this_ptr, "initialize"); } /** * Retrieve the data */ PHALCON_OBS_VAR(data); phalcon_read_property(&data, this_ptr, SL("_data"), PH_NOISY_CC); if (phalcon_array_isset(data, property)) { PHALCON_OBS_VAR(value); phalcon_array_fetch(&value, data, property, PH_NOISY_CC); if (PHALCON_IS_NOT_EMPTY(value)) { RETURN_CCTOR(value); } } RETURN_CCTOR(default_value); }
/** * Obtains a value from the session bag optionally setting a default value * *<code> * echo $user->get('name', 'Kimbra'); *</code> * * @param string $property * @param string $defaultValue * @return mixed */ PHP_METHOD(Phalcon_Session_Bag, get){ zval *property, *default_value = NULL, *initalized; zval *data, *value; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &property, &default_value); if (!default_value) { PHALCON_INIT_VAR(default_value); } /** * Check first if the bag is initialized */ PHALCON_OBS_VAR(initalized); phalcon_read_property_this(&initalized, this_ptr, SL("_initalized"), PH_NOISY_CC); if (PHALCON_IS_FALSE(initalized)) { phalcon_call_method_noret(this_ptr, "initialize"); } /** * Retrieve the data */ PHALCON_OBS_VAR(data); phalcon_read_property_this(&data, this_ptr, SL("_data"), PH_NOISY_CC); if (phalcon_array_isset(data, property)) { PHALCON_OBS_VAR(value); phalcon_array_fetch(&value, data, property, PH_NOISY); if (PHALCON_IS_NOT_EMPTY(value)) { RETURN_CCTOR(value); } } RETURN_CCTOR(default_value); }
/** * Render the image and return the binary string. * * @param string $ext image type to return: png, jpg, gif, etc * @param int $quality quality of image: 1-100 * @return Phalcon\Image\Adapter */ PHP_METHOD(Phalcon_Image_Adapter, render) { zval *ext = NULL, *quality = NULL, *constant, *file; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 2, &ext, &quality); if (!ext) { file = phalcon_fetch_nproperty_this(this_ptr, SL("_file"), PH_NOISY TSRMLS_CC); PHALCON_INIT_VAR(constant); if (!zend_get_constant(SL("PATHINFO_EXTENSION"), constant TSRMLS_CC)) { RETURN_MM(); } ext = NULL; PHALCON_CALL_FUNCTION(&ext, "pathinfo", file, constant); if (!PHALCON_IS_NOT_EMPTY(ext)) { ZVAL_STRING(ext, "png", 1); } } if (!quality) { PHALCON_INIT_VAR(quality); ZVAL_LONG(quality, 100); } else { if (Z_TYPE_P(quality) != IS_LONG) { PHALCON_SEPARATE_PARAM(quality); convert_to_long(quality); } } PHALCON_RETURN_CALL_METHOD(this_ptr, "_render", ext, quality); RETURN_MM(); }
/** * Rpc call * * @param string $method * @param string $data * @return Phalcon\JsonRpc\Response */ PHP_METHOD(Phalcon_JsonRpc_Client, call){ zval *method = NULL, *data = NULL, *httpclient, *id, *jsonrpc_message, *json_message = NULL, *response = NULL; zval *code = NULL, *body = NULL, *json = NULL, *jsonrpc_response, *result, *error; int i; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &method, &data); httpclient = phalcon_fetch_nproperty_this(this_ptr, SL("_httpclient"), PH_NOISY TSRMLS_CC); id = phalcon_fetch_nproperty_this(this_ptr, SL("_id"), PH_NOISY TSRMLS_CC); i = Z_LVAL_P(id) + 1; ZVAL_LONG(id, i); phalcon_update_property_this(this_ptr, SL("_id"), id TSRMLS_CC); PHALCON_INIT_VAR(jsonrpc_message); array_init(jsonrpc_message); phalcon_array_update_string_string(&jsonrpc_message, SL("jsonrpc"), SL("2.0"), 0); phalcon_array_update_string(&jsonrpc_message, SL("method"), method, PH_COPY); if (data) { phalcon_array_update_string(&jsonrpc_message, SL("params"), data, PH_COPY); } phalcon_array_update_string(&jsonrpc_message, SL("id"), id, PH_COPY); PHALCON_CALL_FUNCTION(&json_message, "json_encode", jsonrpc_message); PHALCON_CALL_METHOD(NULL, httpclient, "setdata", json_message); PHALCON_CALL_METHOD(&response, httpclient, "post"); PHALCON_VERIFY_CLASS_EX(response, phalcon_http_client_response_ce, phalcon_jsonrpc_client_exception_ce, 1); PHALCON_CALL_METHOD(&code, response, "getstatuscode"); PHALCON_CALL_METHOD(&body, response, "getbody"); PHALCON_INIT_VAR(jsonrpc_response); object_init_ex(jsonrpc_response, phalcon_jsonrpc_client_response_ce); PHALCON_CALL_METHOD(NULL, jsonrpc_response, "__construct", body); PHALCON_CALL_METHOD(NULL, jsonrpc_response, "setcode", code); if (PHALCON_IS_NOT_EMPTY(body)) { PHALCON_CALL_FUNCTION(&json, "json_decode", body, PHALCON_GLOBAL(z_true)); if (Z_TYPE_P(json) == IS_ARRAY) { if (phalcon_array_isset_string(json, SS("id"))) { PHALCON_OBS_VAR(id); phalcon_array_fetch_string(&id, json, SL("id"), PH_NOISY); PHALCON_CALL_METHOD(NULL, jsonrpc_response, "setid", id); } if (phalcon_array_isset_string(json, SS("result"))) { PHALCON_OBS_VAR(result); phalcon_array_fetch_string(&result, json, SL("result"), PH_NOISY); PHALCON_CALL_METHOD(NULL, jsonrpc_response, "setresult", result); } if (phalcon_array_isset_string(json, SS("error"))) { PHALCON_OBS_VAR(error); phalcon_array_fetch_string(&error, json, SL("error"), PH_NOISY); PHALCON_CALL_METHOD(NULL, jsonrpc_response, "seterror", error); } } } RETURN_CTOR(jsonrpc_response); }
/** * Sends the cookie to the HTTP client * Stores the cookie definition in session * * @return Phalcon\Http\Cookie */ PHP_METHOD(Phalcon_Http_Cookie, send){ zval *name, *value, *expire, *domain, *path, *secure; zval *http_only, *dependency_injector, *definition; zval *service = NULL, *session = NULL, *key, *encryption, *crypt = NULL; zval *encrypt_value = NULL, *has_session = NULL; PHALCON_MM_GROW(); name = phalcon_read_property(getThis(), SL("_name"), PH_NOISY); value = phalcon_read_property(getThis(), SL("_value"), PH_NOISY); expire = phalcon_read_property(getThis(), SL("_expire"), PH_NOISY); domain = phalcon_read_property(getThis(), SL("_domain"), PH_NOISY); path = phalcon_read_property(getThis(), SL("_path"), PH_NOISY); secure = phalcon_read_property(getThis(), SL("_secure"), PH_NOISY); http_only = phalcon_read_property(getThis(), SL("_httpOnly"), PH_NOISY); dependency_injector = phalcon_read_property(getThis(), SL("_dependencyInjector"), PH_NOISY); if (Z_TYPE_P(dependency_injector) == IS_OBJECT) { PHALCON_INIT_VAR(service); ZVAL_STR(service, IS(session)); PHALCON_CALL_METHOD(&has_session, dependency_injector, "has", service); if (zend_is_true(has_session)) { PHALCON_INIT_VAR(definition); array_init(definition); if (!PHALCON_IS_LONG(expire, 0)) { phalcon_array_update_str(definition, SL("expire"), expire, PH_COPY); } if (PHALCON_IS_NOT_EMPTY(path)) { phalcon_array_update_str(definition, SL("path"), path, PH_COPY); } if (PHALCON_IS_NOT_EMPTY(domain)) { phalcon_array_update_string(definition, IS(domain), domain, PH_COPY); } if (PHALCON_IS_NOT_EMPTY(secure)) { phalcon_array_update_str(definition, SL("secure"), secure, PH_COPY); } if (PHALCON_IS_NOT_EMPTY(http_only)) { phalcon_array_update_str(definition, SL("httpOnly"), http_only, PH_COPY); } /** * The definition is stored in session */ if (phalcon_fast_count_ev(definition)) { PHALCON_CALL_METHOD(&session, dependency_injector, "getshared", service); if (Z_TYPE_P(session) != IS_NULL) { PHALCON_VERIFY_INTERFACE(session, phalcon_session_adapterinterface_ce); PHALCON_INIT_VAR(key); PHALCON_CONCAT_SV(key, "_PHCOOKIE_", name); PHALCON_CALL_METHOD(NULL, session, "set", key, definition); } } } } encryption = phalcon_read_property(getThis(), SL("_useEncryption"), PH_NOISY); if (zend_is_true(encryption) && PHALCON_IS_NOT_EMPTY(value)) { if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_http_cookie_exception_ce, "A dependency injection object is required to access the 'filter' service"); return; } PHALCON_INIT_NVAR(service); ZVAL_STRING(service, "crypt"); PHALCON_CALL_METHOD(&crypt, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(crypt, phalcon_cryptinterface_ce); /** * Encrypt the value also coding it with base64 */ PHALCON_CALL_METHOD(&encrypt_value, crypt, "encryptbase64", value); } else { PHALCON_CPY_WRT(encrypt_value, value); } /** * Sets the cookie using the standard 'setcookie' function */ convert_to_string_ex(name); convert_to_string_ex(encrypt_value); convert_to_long_ex(expire); convert_to_string_ex(path); convert_to_string_ex(domain); convert_to_long_ex(secure); convert_to_long_ex(http_only); php_setcookie(Z_STR_P(name), Z_STR_P(encrypt_value), Z_LVAL_P(expire), Z_STR_P(path), Z_STR_P(domain), Z_LVAL_P(secure), 1, Z_LVAL_P(http_only)); RETURN_THIS(); }
/** * Sends the cookie to the HTTP client * Stores the cookie definition in session * * @return Phalcon\Http\Cookie */ PHP_METHOD(Phalcon_Http_Cookie, send){ zval *name, *value, *expire, *domain, *path, *secure; zval *http_only, *dependency_injector, *definition; zval *service = NULL, *session, *key, *encryption, *crypt; zval *encrypt_value = NULL, *has_session; PHALCON_MM_GROW(); PHALCON_OBS_VAR(name); phalcon_read_property_this(&name, this_ptr, SL("_name"), PH_NOISY_CC); PHALCON_OBS_VAR(value); phalcon_read_property_this(&value, this_ptr, SL("_value"), PH_NOISY_CC); PHALCON_OBS_VAR(expire); phalcon_read_property_this(&expire, this_ptr, SL("_expire"), PH_NOISY_CC); PHALCON_OBS_VAR(domain); phalcon_read_property_this(&domain, this_ptr, SL("_domain"), PH_NOISY_CC); PHALCON_OBS_VAR(path); phalcon_read_property_this(&path, this_ptr, SL("_path"), PH_NOISY_CC); PHALCON_OBS_VAR(secure); phalcon_read_property_this(&secure, this_ptr, SL("_secure"), PH_NOISY_CC); PHALCON_OBS_VAR(http_only); phalcon_read_property_this(&http_only, this_ptr, SL("_httpOnly"), PH_NOISY_CC); 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_VAR(service); PHALCON_INIT_VAR(has_session); ZVAL_STRING(service, "session", 1); phalcon_call_method_p1(has_session, dependency_injector, "has", service); if (zend_is_true(has_session)) { PHALCON_INIT_VAR(definition); array_init(definition); if (!PHALCON_IS_LONG(expire, 0)) { phalcon_array_update_string(&definition, SL("expire"), &expire, PH_COPY); } if (PHALCON_IS_NOT_EMPTY(path)) { phalcon_array_update_string(&definition, SL("path"), &path, PH_COPY); } if (PHALCON_IS_NOT_EMPTY(domain)) { phalcon_array_update_string(&definition, SL("domain"), &domain, PH_COPY); } if (PHALCON_IS_NOT_EMPTY(secure)) { phalcon_array_update_string(&definition, SL("secure"), &secure, PH_COPY); } if (PHALCON_IS_NOT_EMPTY(http_only)) { phalcon_array_update_string(&definition, SL("httpOnly"), &http_only, PH_COPY); } /** * The definition is stored in session */ if (phalcon_fast_count_ev(definition TSRMLS_CC)) { PHALCON_INIT_VAR(session); phalcon_call_method_p1(session, dependency_injector, "getshared", service); if (Z_TYPE_P(session) != IS_NULL) { PHALCON_INIT_VAR(key); PHALCON_CONCAT_SV(key, "_PHCOOKIE_", name); phalcon_call_method_p2_noret(session, "set", key, definition); } } } } PHALCON_OBS_VAR(encryption); phalcon_read_property_this(&encryption, this_ptr, SL("_useEncryption"), PH_NOISY_CC); if (zend_is_true(encryption) && PHALCON_IS_NOT_EMPTY(value)) { if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_http_response_exception_ce, "A dependency injection object is required to access the 'filter' service"); return; } PHALCON_INIT_NVAR(service); ZVAL_STRING(service, "crypt", 1); PHALCON_INIT_VAR(crypt); phalcon_call_method_p1(crypt, dependency_injector, "getshared", service); /** * Encrypt the value also coding it with base64 */ PHALCON_INIT_VAR(encrypt_value); phalcon_call_method_p1(encrypt_value, crypt, "encryptbase64", value); } else { PHALCON_CPY_WRT(encrypt_value, value); } /** * Sets the cookie using the standard 'setcookie' function */ convert_to_string_ex(&name); convert_to_string_ex(&encrypt_value); convert_to_long_ex(&expire); convert_to_string_ex(&path); convert_to_string_ex(&domain); convert_to_long_ex(&secure); convert_to_long_ex(&http_only); php_setcookie( Z_STRVAL_P(name), Z_STRLEN_P(name), Z_STRVAL_P(encrypt_value), Z_STRLEN_P(encrypt_value), Z_LVAL_P(expire), Z_STRVAL_P(path), Z_STRLEN_P(path), Z_STRVAL_P(domain), Z_STRLEN_P(domain), Z_LVAL_P(secure), 1, Z_LVAL_P(http_only) TSRMLS_CC ); RETURN_THIS(); }
/** * Returns the cookie's value * * @param string|array $filters * @param string $defaultValue * @return mixed */ PHP_METHOD(Phalcon_Http_Cookie, getValue) { zval *filters = NULL, *default_value = NULL, *restored, *dependency_injector = NULL, *readed, *name, *_COOKIE, value = {}, *encryption; zval service = {}, crypt = {}, decrypted_value = {}, filter = {}; phalcon_fetch_params(0, 0, 2, &filters, &default_value); if (!filters) { filters = &PHALCON_GLOBAL(z_null); } if (!default_value) { default_value = &PHALCON_GLOBAL(z_null); } restored = phalcon_read_property(getThis(), SL("_restored"), PH_NOISY); if (!zend_is_true(restored)) { PHALCON_CALL_METHODW(NULL, getThis(), "restore"); } dependency_injector = phalcon_read_property(getThis(), SL("_dependencyInjector"), PH_NOISY); if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STRW(phalcon_http_cookie_exception_ce, "A dependency injection object is required to access the 'filter' service"); return; } readed = phalcon_read_property(getThis(), SL("_readed"), PH_NOISY); if (PHALCON_IS_FALSE(readed)) { name = phalcon_read_property(getThis(), SL("_name"), PH_NOISY); _COOKIE = phalcon_get_global_str(SL("_COOKIE")); if (phalcon_array_isset_fetch(&value, _COOKIE, name)) { encryption = phalcon_read_property(getThis(), SL("_useEncryption"), PH_NOISY); if (zend_is_true(encryption) && PHALCON_IS_NOT_EMPTY(&value)) { ZVAL_STRING(&service, "crypt"); PHALCON_CALL_METHODW(&crypt, dependency_injector, "getshared", &service); PHALCON_VERIFY_INTERFACEW(&crypt, phalcon_cryptinterface_ce); /** * Decrypt the value also decoding it with base64 */ PHALCON_CALL_METHODW(&decrypted_value, &crypt, "decryptbase64", &value); } else { PHALCON_CPY_WRT_CTOR(&decrypted_value, &value); } /** * Update the decrypted value */ phalcon_update_property_this(getThis(), SL("_value"), &decrypted_value); if (Z_TYPE_P(filters) != IS_NULL) { phalcon_return_property(&filter, getThis(), SL("_filter")); if (Z_TYPE(filter) != IS_OBJECT) { ZVAL_STRING(&service, ISV(filter)); PHALCON_CALL_METHODW(&filter, dependency_injector, "getshared", &service); PHALCON_VERIFY_INTERFACEW(&filter, phalcon_filterinterface_ce); phalcon_update_property_this(getThis(), SL("_filter"), &filter); } PHALCON_RETURN_CALL_METHOD(&filter, "sanitize", &decrypted_value, filters); return; } /** * Return the value without filtering */ RETURN_CTORW(&decrypted_value); } RETURN_CTORW(default_value); } phalcon_return_property(&value, getThis(), SL("_value")); RETURN_CTORW(&value); }
/** * Handles a MVC request * * @param string $uri * @return Phalcon\Http\ResponseInterface */ PHP_METHOD(Phalcon_Mvc_JsonRpc, handle){ zval *uri = NULL, *dependency_injector, *events_manager; zval *status = NULL, *service = NULL, *request = NULL, *response = NULL; zval *json = NULL, *data = NULL, *jsonrpc_message, *jsonrpc_error, *jsonrpc_result = NULL; zval *jsonrpc_method, *jsonrpc_params, *jsonrpc_id; zval *url = NULL, *router = NULL, *module_name = NULL; zval *module_object = NULL, *modules; zval *module, *class_name = NULL, *module_params; zval *namespace_name = NULL; zval *controller_name = NULL, *action_name = NULL, *params = NULL, *exact = NULL; zval *dispatcher = NULL, *controller = NULL, *returned_response = NULL; zval *path; PHALCON_MM_GROW(); dependency_injector = phalcon_read_property(getThis(), SL("_dependencyInjector"), PH_NOISY); if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_jsonrpc_exception_ce, "A dependency injection object is required to access internal services"); return; } events_manager = phalcon_read_property(getThis(), SL("_eventsManager"), PH_NOISY); if (Z_TYPE_P(events_manager) != IS_OBJECT) { events_manager = NULL; } else { PHALCON_VERIFY_INTERFACE_EX(events_manager, phalcon_events_managerinterface_ce, phalcon_mvc_jsonrpc_exception_ce, 1); } /* Call boot event, this allows the developer to perform initialization actions */ if (FAILURE == phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:boot", getThis(), NULL)) { RETURN_MM_FALSE; } /* Deserializer Json */ PHALCON_INIT_NVAR(service); ZVAL_STR(service, IS(request)); PHALCON_CALL_METHOD(&request, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(request, phalcon_http_requestinterface_ce); PHALCON_CALL_METHOD(&json, request, "getrawbody"); PHALCON_CALL_FUNCTION(&data, "json_decode", json, &PHALCON_GLOBAL(z_true)); PHALCON_INIT_NVAR(service); ZVAL_STR(service, IS(response)); PHALCON_CALL_METHOD(&response, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(response, phalcon_http_responseinterface_ce); PHALCON_INIT_VAR(jsonrpc_message); array_init(jsonrpc_message); PHALCON_INIT_VAR(jsonrpc_error); array_init(jsonrpc_error); if (PHALCON_IS_EMPTY(data)) { phalcon_array_update_str_long(jsonrpc_error, SL("code"), __LINE__, 0); phalcon_array_update_str_str(jsonrpc_error, SL("message"), SL("Parse error"), PH_COPY); } else if (Z_TYPE_P(data) != IS_ARRAY) { phalcon_array_update_str_long(jsonrpc_error, SL("code"), __LINE__, 0); phalcon_array_update_str_str(jsonrpc_error, SL("message"), SL("Parse error"), PH_COPY); } else if (!phalcon_array_isset_str(data, SL("jsonrpc"))) { phalcon_array_update_str_long(jsonrpc_error, SL("code"), __LINE__, 0); phalcon_array_update_str_str(jsonrpc_error, SL("message"), SL("Invalid Request"), PH_COPY); } else if (!phalcon_array_isset_str(data, SL("method"))) { phalcon_array_update_str_long(jsonrpc_error, SL("code"), __LINE__, 0); phalcon_array_update_str_str(jsonrpc_error, SL("message"), SL("Invalid Request"), PH_COPY); } else { PHALCON_OBS_VAR(jsonrpc_method); phalcon_array_fetch_str(&jsonrpc_method, data, SL("method"), PH_NOISY); if (phalcon_array_isset_str(data, SL("params"))) { PHALCON_OBS_VAR(jsonrpc_params); phalcon_array_fetch_str(&jsonrpc_params, data, SL("params"), PH_NOISY); } else { PHALCON_INIT_VAR(jsonrpc_params); array_init(jsonrpc_params); } PHALCON_INIT_NVAR(service); ZVAL_STR(service, IS(url)); PHALCON_CALL_METHOD(&url, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(url, phalcon_mvc_urlinterface_ce); PHALCON_CALL_METHOD(&uri, url, "get", jsonrpc_method); PHALCON_INIT_NVAR(service); ZVAL_STR(service, IS(router)); PHALCON_CALL_METHOD(&router, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(router, phalcon_mvc_routerinterface_ce); /* Handle the URI pattern (if any) */ PHALCON_CALL_METHOD(NULL, router, "handle", uri); /* Load module config */ PHALCON_CALL_METHOD(&module_name, router, "getmodulename"); /* Load module config */ PHALCON_CALL_METHOD(&module_name, router, "getmodulename"); /* If the router doesn't return a valid module we use the default module */ if (!zend_is_true(module_name)) { module_name = phalcon_read_property(getThis(), SL("_defaultModule"), PH_NOISY); } /** * Process the module definition */ if (zend_is_true(module_name)) { if (FAILURE == phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:beforeStartModule", getThis(), module_name)) { RETURN_MM_FALSE; } /** * Check if the module passed by the router is registered in the modules container */ modules = phalcon_read_property(getThis(), SL("_modules"), PH_NOISY); if (!phalcon_array_isset_fetch(&module, modules, module_name)) { convert_to_string(module_name); zend_throw_exception_ex(phalcon_mvc_jsonrpc_exception_ce, 0, "Module %s is not registered in the jsonrpc container", Z_STRVAL_P(module_name)); RETURN_MM(); } /** * A module definition must be an array or an object */ if (Z_TYPE_P(module) != IS_ARRAY && Z_TYPE_P(module) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_jsonrpc_exception_ce, "Invalid module definition"); return; } /* An array module definition contains a path to a module definition class */ if (Z_TYPE_P(module) == IS_ARRAY) { /* Class name used to load the module definition */ if (phalcon_array_isset_str(module, SL("className"))) { PHALCON_OBS_VAR(class_name); phalcon_array_fetch_str(&class_name, module, SL("className"), PH_NOISY); } else { PHALCON_INIT_NVAR(class_name); ZVAL_STRING(class_name, "Module"); } /* If the developer has specified a path, try to include the file */ if (phalcon_array_isset_str(module, SL("path"))) { PHALCON_OBS_VAR(path); phalcon_array_fetch_str(&path, module, SL("path"), PH_NOISY); convert_to_string_ex(path); if (Z_TYPE_P(class_name) != IS_STRING || phalcon_class_exists(class_name, 0) == NULL) { if (phalcon_file_exists(path) == SUCCESS) { RETURN_MM_ON_FAILURE(phalcon_require(Z_STRVAL_P(path))); } else { zend_throw_exception_ex(phalcon_mvc_jsonrpc_exception_ce, 0, "Module definition path '%s' does not exist", Z_STRVAL_P(path)); RETURN_MM(); } } } PHALCON_CALL_METHOD(&module_object, dependency_injector, "get", class_name); /** * 'registerAutoloaders' and 'registerServices' are automatically called */ PHALCON_CALL_METHOD(NULL, module_object, "registerautoloaders", dependency_injector); PHALCON_CALL_METHOD(NULL, module_object, "registerservices", dependency_injector); } else if (Z_TYPE_P(module) == IS_OBJECT && instanceof_function(Z_OBJCE_P(module), zend_ce_closure)) { /* A module definition object, can be a Closure instance */ PHALCON_INIT_VAR(module_params); array_init_size(module_params, 1); phalcon_array_append(module_params, dependency_injector, PH_COPY); PHALCON_CALL_USER_FUNC_ARRAY(&status, module, module_params); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_jsonrpc_exception_ce, "Invalid module definition"); return; } /* Calling afterStartModule event */ if (events_manager) { if (!module_object) { module_object = &PHALCON_GLOBAL(z_null); } phalcon_update_property_this(getThis(), SL("_moduleObject"), module_object); if (FAILURE == phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:afterStartModule", getThis(), module_name)) { RETURN_MM_FALSE; } } } /* We get the parameters from the router and assign them to the dispatcher */ PHALCON_CALL_METHOD(&module_name, router, "getmodulename"); PHALCON_CALL_METHOD(&namespace_name, router, "getnamespacename"); PHALCON_CALL_METHOD(&controller_name, router, "getcontrollername"); PHALCON_CALL_METHOD(&action_name, router, "getactionname"); PHALCON_CALL_METHOD(¶ms, router, "getparams"); PHALCON_CALL_METHOD(&exact, router, "isexactcontrollername"); PHALCON_INIT_NVAR(service); ZVAL_STR(service, IS(dispatcher)); PHALCON_CALL_METHOD(&dispatcher, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(dispatcher, phalcon_dispatcherinterface_ce); /* Assign the values passed from the router */ PHALCON_CALL_METHOD(NULL, dispatcher, "setmodulename", module_name); PHALCON_CALL_METHOD(NULL, dispatcher, "setnamespacename", namespace_name); PHALCON_CALL_METHOD(NULL, dispatcher, "setcontrollername", controller_name, exact); PHALCON_CALL_METHOD(NULL, dispatcher, "setactionname", action_name); PHALCON_CALL_METHOD(NULL, dispatcher, "setparams", jsonrpc_params); /* Calling beforeHandleRequest */ RETURN_MM_ON_FAILURE(phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:beforeHandleRequest", getThis(), dispatcher)); /* The dispatcher must return an object */ PHALCON_CALL_METHOD(&controller, dispatcher, "dispatch"); PHALCON_INIT_VAR(returned_response); /* Get the latest value returned by an action */ PHALCON_CALL_METHOD(&jsonrpc_result, dispatcher, "getreturnedvalue"); } /* Calling afterHandleRequest */ if (FAILURE == phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:afterHandleRequest", getThis(), controller) && EG(exception)) { RETURN_MM(); } phalcon_array_update_str_str(jsonrpc_message, SL("jsonrpc"), SL("2.0"), PH_COPY); if (PHALCON_IS_NOT_EMPTY(jsonrpc_error)) { phalcon_array_update_str(jsonrpc_message, SL("error"), jsonrpc_error, PH_COPY); } if (jsonrpc_result != NULL) { phalcon_array_update_str(jsonrpc_message, SL("result"), jsonrpc_result, PH_COPY); } if (phalcon_array_isset_str_fetch(&jsonrpc_id, data, SL("id"))) { phalcon_array_update_str(jsonrpc_message, SL("id"), jsonrpc_id, PH_COPY); } else { phalcon_array_update_str(jsonrpc_message, SL("id"), &PHALCON_GLOBAL(z_null), PH_COPY); } PHALCON_CALL_METHOD(NULL, response, "setjsoncontent", jsonrpc_message); /* Calling beforeSendResponse */ if (FAILURE == phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:beforeSendResponse", getThis(), response) && EG(exception)) { RETURN_MM(); } /* Headers are automatically sent */ PHALCON_CALL_METHOD(NULL, response, "sendheaders"); /* Cookies are automatically sent */ PHALCON_CALL_METHOD(NULL, response, "sendcookies"); /* Return the response */ RETURN_CCTOR(response); }
/** * Transform an intermediate representation for a schema/table into a database system valid expression * * @param array $table * @param string $escapeChar * @return string */ PHP_METHOD(Phalcon_Db_Dialect, getSqlTable){ zval *table, *escape_char = NULL, *table_name, *sql_table = NULL; zval *schema_name, *sql_schema = NULL, *alias_name; zval *sql_table_alias = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &table, &escape_char); if (!escape_char) { PHALCON_INIT_VAR(escape_char); } else { PHALCON_SEPARATE_PARAM(escape_char); } if (Z_TYPE_P(escape_char) == IS_NULL) { PHALCON_OBS_NVAR(escape_char); phalcon_read_property_this(&escape_char, this_ptr, SL("_escapeChar"), PH_NOISY TSRMLS_CC); } if (Z_TYPE_P(table) == IS_ARRAY) { /** * The index '0' is the table name */ PHALCON_OBS_VAR(table_name); phalcon_array_fetch_long(&table_name, table, 0, PH_NOISY); if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_VAR(sql_table); PHALCON_CONCAT_VVV(sql_table, escape_char, table_name, escape_char); } else { PHALCON_CPY_WRT(sql_table, table_name); } /** * The index '1' is the schema name */ PHALCON_OBS_VAR(schema_name); phalcon_array_fetch_long(&schema_name, table, 1, PH_NOISY); if (PHALCON_IS_NOT_EMPTY(schema_name)) { if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_VAR(sql_schema); PHALCON_CONCAT_VVVSV(sql_schema, escape_char, schema_name, escape_char, ".", sql_table); } else { PHALCON_INIT_NVAR(sql_schema); PHALCON_CONCAT_VSV(sql_schema, schema_name, ".", sql_table); } } else { PHALCON_CPY_WRT(sql_schema, sql_table); } /** * The index '2' is the table alias */ if (phalcon_array_isset_long(table, 2)) { PHALCON_OBS_VAR(alias_name); phalcon_array_fetch_long(&alias_name, table, 2, PH_NOISY); if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_VAR(sql_table_alias); PHALCON_CONCAT_VSVVV(sql_table_alias, sql_schema, " AS ", escape_char, alias_name, escape_char); } else { PHALCON_INIT_NVAR(sql_table_alias); PHALCON_CONCAT_VSV(sql_table_alias, sql_schema, " AS ", alias_name); } } else { PHALCON_CPY_WRT(sql_table_alias, sql_schema); } RETURN_CTOR(sql_table_alias); } if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_CONCAT_VVV(return_value, escape_char, table, escape_char); RETURN_MM(); } RETURN_CTOR(table); }
/** * Traverses a collection calling the callback to generate its HTML * * @param Phalcon\Assets\Collection $collection * @param callback $callback * @param string $type * @param array $args */ PHP_METHOD(Phalcon_Assets_Manager, output){ zval *collection, *callback, *type = NULL, *args = NULL, *output, *use_implicit_output; zval *resources = NULL, *filters = NULL, *prefix = NULL, *source_base_path = NULL; zval *target_base_path = NULL, *options, *collection_source_path = NULL; zval *complete_source_path = NULL, *collection_target_path = NULL; zval *complete_target_path = NULL, *filtered_joined_content = NULL; zval *join = NULL, *exception_message = NULL, *is_directory; zval *resource = NULL, *filter_needed = NULL, *local = NULL, *source_path = NULL; zval *target_path = NULL, *path = NULL, *prefixed_path = NULL, *attributes = NULL; zval *parameters = NULL, *html = NULL, *content = NULL, *must_filter = NULL; zval *filter = NULL, *filtered_content = NULL, *target_uri = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; zval *type_css; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 2, &collection, &callback, &type, &args); if (!args) { args = PHALCON_GLOBAL(z_null); } PHALCON_INIT_VAR(output); PHALCON_OBS_VAR(use_implicit_output); phalcon_read_property_this(&use_implicit_output, this_ptr, SL("_implicitOutput"), PH_NOISY TSRMLS_CC); /** * Get the resources as an array */ PHALCON_CALL_METHOD(&resources, collection, "getresources"); /** * Get filters in the collection */ PHALCON_CALL_METHOD(&filters, collection, "getfilters"); /** * Get the collection's prefix */ PHALCON_CALL_METHOD(&prefix, collection, "getprefix"); PHALCON_INIT_VAR(type_css); ZVAL_STRING(type_css, "css", 1); /** * Prepare options if the collection must be filtered */ if (Z_TYPE_P(filters) == IS_ARRAY) { PHALCON_INIT_VAR(source_base_path); PHALCON_INIT_VAR(target_base_path); PHALCON_OBS_VAR(options); phalcon_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY TSRMLS_CC); /** * Check for global options in the assets manager */ if (Z_TYPE_P(options) == IS_ARRAY) { /** * The source base path is a global location where all resources are located */ if (phalcon_array_isset_string(options, SS("sourceBasePath"))) { PHALCON_OBS_NVAR(source_base_path); phalcon_array_fetch_string(&source_base_path, options, SL("sourceBasePath"), PH_NOISY); } /** * The target base path is a global location where all resources are written */ if (phalcon_array_isset_string(options, SS("targetBasePath"))) { PHALCON_OBS_NVAR(target_base_path); phalcon_array_fetch_string(&target_base_path, options, SL("targetBasePath"), PH_NOISY); } } /** * Check if the collection have its own source base path */ PHALCON_CALL_METHOD(&collection_source_path, collection, "getsourcepath"); /** * Concatenate the global base source path with the collection one */ if (PHALCON_IS_NOT_EMPTY(collection_source_path)) { PHALCON_INIT_VAR(complete_source_path); PHALCON_CONCAT_VV(complete_source_path, source_base_path, collection_source_path); } else { PHALCON_CPY_WRT(complete_source_path, source_base_path); } /** * Check if the collection have its own target base path */ PHALCON_CALL_METHOD(&collection_target_path, collection, "gettargetpath"); /** * Concatenate the global base source path with the collection one */ if (PHALCON_IS_NOT_EMPTY(collection_target_path)) { PHALCON_INIT_VAR(complete_target_path); PHALCON_CONCAT_VV(complete_target_path, target_base_path, collection_target_path); } else { PHALCON_CPY_WRT(complete_target_path, target_base_path); } /** * Global filtered content */ PHALCON_INIT_VAR(filtered_joined_content); /** * Check if all the resources in the collection must be joined */ PHALCON_CALL_METHOD(&join, collection, "getjoin"); /** * Check for valid target paths if the collection must be joined */ if (zend_is_true(join)) { /** * We need a valid final target path */ if (PHALCON_IS_EMPTY(complete_target_path)) { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Path '", complete_target_path, "' is not a valid target path (1)"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_assets_exception_ce, exception_message); return; } PHALCON_INIT_VAR(is_directory); phalcon_is_dir(is_directory, complete_target_path TSRMLS_CC); /** * The targetpath needs to be a valid file */ if (PHALCON_IS_TRUE(is_directory)) { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Path '", complete_target_path, "' is not a valid target path (2)"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_assets_exception_ce, exception_message); return; } } } phalcon_is_iterable(resources, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(resource); PHALCON_INIT_NVAR(filter_needed); ZVAL_FALSE(filter_needed); if (!type) { PHALCON_CALL_METHOD(&type, resource, "gettype"); } /** * Is the resource local? */ PHALCON_CALL_METHOD(&local, resource, "getlocal"); /** * If the collection must not be joined we must print a HTML for each one */ if (Z_TYPE_P(filters) == IS_ARRAY) { if (zend_is_true(local)) { /** * Get the complete path */ PHALCON_CALL_METHOD(&source_path, resource, "getrealsourcepath", complete_source_path); /** * We need a valid source path */ if (!zend_is_true(source_path)) { PHALCON_CALL_METHOD(&source_path, resource, "getpath"); PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Resource '", source_path, "' does not have a valid source path"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_assets_exception_ce, exception_message); return; } } else { /** * Get the complete source path */ PHALCON_CALL_METHOD(&source_path, resource, "getpath"); /** * resources paths are always filtered */ PHALCON_INIT_NVAR(filter_needed); ZVAL_TRUE(filter_needed); } /** * Get the target path, we need to write the filtered content to a file */ PHALCON_CALL_METHOD(&target_path, resource, "getrealtargetpath", complete_target_path); /** * We need a valid final target path */ if (PHALCON_IS_EMPTY(target_path)) { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Resource '", source_path, "' does not have a valid target path"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_assets_exception_ce, exception_message); return; } if (zend_is_true(local)) { /** * Make sure the target path is not the same source path */ if (PHALCON_IS_EQUAL(target_path, source_path)) { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Resource '", target_path, "' have the same source and target paths"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_assets_exception_ce, exception_message); return; } if (phalcon_file_exists(target_path TSRMLS_CC) == SUCCESS) { if (phalcon_compare_mtime(target_path, source_path TSRMLS_CC)) { PHALCON_INIT_NVAR(filter_needed); ZVAL_TRUE(filter_needed); } } else { PHALCON_INIT_NVAR(filter_needed); ZVAL_TRUE(filter_needed); } } } /** * If there are no filters, just print/buffer the HTML */ if (Z_TYPE_P(filters) != IS_ARRAY) { PHALCON_CALL_METHOD(&path, resource, "getrealtargeturi"); if (Z_TYPE_P(prefix) != IS_NULL) { PHALCON_INIT_NVAR(prefixed_path); PHALCON_CONCAT_VV(prefixed_path, prefix, path); } else { PHALCON_CPY_WRT(prefixed_path, path); } /** * Gets extra HTML attributes in the resource */ PHALCON_CALL_METHOD(&attributes, resource, "getattributes"); /** * Prepare the parameters for the callback */ PHALCON_INIT_NVAR(parameters); array_init_size(parameters, 3); if (Z_TYPE_P(attributes) == IS_ARRAY) { phalcon_array_update_long(&attributes, 0, prefixed_path, PH_COPY); phalcon_array_append(¶meters, attributes, PH_COPY); } else { phalcon_array_append(¶meters, prefixed_path, PH_COPY); } phalcon_array_append(¶meters, local, PH_COPY); phalcon_array_append(¶meters, args, PH_COPY); /** * Call the callback to generate the HTML */ PHALCON_INIT_NVAR(html);/**/ PHALCON_CALL_USER_FUNC_ARRAY(html, callback, parameters); /** * Implicit output prints the content directly */ if (zend_is_true(use_implicit_output)) { zend_print_zval(html, 0); } else { phalcon_concat_self(&output, html TSRMLS_CC); } zend_hash_move_forward_ex(ah0, &hp0); continue; } if (zend_is_true(filter_needed)) { /** * Get the resource's content */ PHALCON_CALL_METHOD(&content, resource, "getcontent", complete_source_path); /** * Check if the resource must be filtered */ PHALCON_CALL_METHOD(&must_filter, resource, "getfilter"); /** * Only filter the resource if it's marked as 'filterable' */ if (zend_is_true(must_filter)) { phalcon_is_iterable(filters, &ah1, &hp1, 0, 0); while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_HVALUE(filter); /** * Filters must be valid objects */ if (Z_TYPE_P(filter) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_assets_exception_ce, "Filter is invalid"); return; } /** * Calls the method 'filter' which must return a filtered version of the content */ PHALCON_CALL_METHOD(&filtered_content, filter, "filter", content); PHALCON_CPY_WRT_CTOR(content, filtered_content); zend_hash_move_forward_ex(ah1, &hp1); } /** * Update the joined filtered content */ if (zend_is_true(join)) { if (PHALCON_IS_EQUAL(type, type_css)) { if (Z_TYPE_P(filtered_joined_content) == IS_NULL) { PHALCON_INIT_NVAR(filtered_joined_content); PHALCON_CONCAT_VS(filtered_joined_content, content, ""); } else { PHALCON_SCONCAT_VS(filtered_joined_content, content, ""); } } else { if (Z_TYPE_P(filtered_joined_content) == IS_NULL) { PHALCON_INIT_NVAR(filtered_joined_content); PHALCON_CONCAT_VS(filtered_joined_content, content, ";"); } else { PHALCON_SCONCAT_VS(filtered_joined_content, content, ";"); } } } } else { /** * Update the joined filtered content */ if (zend_is_true(join)) { if (Z_TYPE_P(filtered_joined_content) == IS_NULL) { PHALCON_CPY_WRT(filtered_joined_content, content); } else { phalcon_concat_self(&filtered_joined_content, content TSRMLS_CC); } } else { PHALCON_CPY_WRT(filtered_content, content); } } if (!zend_is_true(join)) { /** * Write the file using file-put-contents. This respects the openbase-dir also * writes to streams */ phalcon_file_put_contents(NULL, target_path, filtered_content TSRMLS_CC); } } if (!zend_is_true(join)) { /** * Generate the HTML using the original path in the resource */ PHALCON_CALL_METHOD(&path, resource, "getrealtargeturi"); if (Z_TYPE_P(prefix) != IS_NULL) { PHALCON_INIT_NVAR(prefixed_path); PHALCON_CONCAT_VV(prefixed_path, prefix, path); } else { PHALCON_CPY_WRT(prefixed_path, path); } /** * Gets extra HTML attributes in the resource */ PHALCON_CALL_METHOD(&attributes, resource, "getattributes"); /** * Filtered resources are always local */ PHALCON_INIT_NVAR(local); ZVAL_TRUE(local); /** * Prepare the parameters for the callback */ PHALCON_INIT_NVAR(parameters); array_init_size(parameters, 3); if (Z_TYPE_P(attributes) == IS_ARRAY) { phalcon_array_update_long(&attributes, 0, prefixed_path, PH_COPY); phalcon_array_append(¶meters, attributes, PH_COPY); } else { phalcon_array_append(¶meters, prefixed_path, PH_COPY); } phalcon_array_append(¶meters, local, PH_COPY); phalcon_array_append(¶meters, args, PH_COPY); /** * Call the callback to generate the HTML */ PHALCON_INIT_NVAR(html);/**/ PHALCON_CALL_USER_FUNC_ARRAY(html, callback, parameters); /** * Implicit output prints the content directly */ if (zend_is_true(use_implicit_output)) { zend_print_zval(html, 0); } else { phalcon_concat_self(&output, html TSRMLS_CC); } } zend_hash_move_forward_ex(ah0, &hp0); } if (Z_TYPE_P(filters) == IS_ARRAY) { if (zend_is_true(join)) { /** * Write the file using file_put_contents. This respects the openbase-dir also * writes to streams */ phalcon_file_put_contents(NULL, complete_target_path, filtered_joined_content TSRMLS_CC); /** * Generate the HTML using the original path in the resource */ PHALCON_CALL_METHOD(&target_uri, collection, "gettargeturi"); if (Z_TYPE_P(prefix) != IS_NULL) { PHALCON_INIT_NVAR(prefixed_path); PHALCON_CONCAT_VV(prefixed_path, prefix, target_uri); } else { PHALCON_CPY_WRT(prefixed_path, target_uri); } /** * Gets extra HTML attributes in the resource */ PHALCON_CALL_METHOD(&attributes, collection, "getattributes"); PHALCON_CALL_METHOD(&local, collection, "gettargetlocal"); /** * Prepare the parameters for the callback */ PHALCON_INIT_NVAR(parameters); array_init_size(parameters, 3); if (Z_TYPE_P(attributes) == IS_ARRAY) { phalcon_array_update_long(&attributes, 0, prefixed_path, PH_COPY); phalcon_array_append(¶meters, attributes, PH_COPY); } else { phalcon_array_append(¶meters, prefixed_path, PH_COPY); } phalcon_array_append(¶meters, local, PH_COPY); phalcon_array_append(¶meters, args, PH_COPY); /** * Call the callback to generate the HTML */ PHALCON_INIT_NVAR(html);/**/ PHALCON_CALL_USER_FUNC_ARRAY(html, callback, parameters); /** * Implicit output prints the content directly */ if (zend_is_true(use_implicit_output)) { zend_print_zval(html, 0); } else { phalcon_concat_self(&output, html TSRMLS_CC); } } } RETURN_CCTOR(output); }
/** * Phalcon\Image\GD constructor * * @param string $file */ PHP_METHOD(Phalcon_Image_Adapter_GD, __construct){ zval *file, *width = NULL, *height = NULL, exception_message = {}, checked = {}, realpath = {}, img_width = {}, img_height = {}, type = {}, mime = {}, format = {}, image = {}, imageinfo = {}, saveflag = {}, blendmode = {}; phalcon_fetch_params(0, 1, 2, &file, &width, &height); if (Z_TYPE_P(file) != IS_STRING) { PHALCON_THROW_EXCEPTION_STRW(phalcon_image_exception_ce, "file parameter should be a string"); return; } phalcon_return_static_property_ce(&checked, phalcon_image_adapter_gd_ce, SL("_checked")); if (!zend_is_true(&checked)) { PHALCON_CALL_CE_STATICW(NULL, phalcon_image_adapter_gd_ce, "check"); } phalcon_update_property_zval(getThis(), SL("_file"), file); if (phalcon_file_exists(file) != FAILURE) { phalcon_file_realpath(&realpath, file); if (unlikely(Z_TYPE(realpath) != IS_STRING)) { convert_to_string(&realpath); } phalcon_update_property_zval(getThis(), SL("_realpath"), &realpath); PHALCON_CALL_FUNCTIONW(&imageinfo, "getimagesize", &realpath); if (phalcon_array_isset_fetch_long(&img_width, &imageinfo, 0)) { phalcon_update_property_zval(getThis(), SL("_width"), &img_width); } if (phalcon_array_isset_fetch_long(&img_height, &imageinfo, 1)) { phalcon_update_property_zval(getThis(), SL("_height"), &img_height); } if (phalcon_array_isset_fetch_long(&type, &imageinfo, 2)) { convert_to_long(&type); phalcon_update_property_zval(getThis(), SL("_type"), &type); } else { ZVAL_LONG(&type, -1); } if (phalcon_array_isset_fetch_str(&mime, &imageinfo, SL("mime"))) { convert_to_string(&mime); phalcon_update_property_zval(getThis(), SL("_mime"), &mime); } assert(Z_TYPE(type) == IS_LONG); switch (Z_LVAL(type)) { case 1: // GIF ZVAL_STRING(&format, "gif"); PHALCON_CALL_FUNCTIONW(&image, "imagecreatefromgif", &realpath); break; case 2: // JPEG ZVAL_STRING(&format, "jpg"); PHALCON_CALL_FUNCTIONW(&image, "imagecreatefromjpeg", &realpath); break; case 3: // PNG ZVAL_STRING(&format, "png"); PHALCON_CALL_FUNCTIONW(&image, "imagecreatefrompng", &realpath); break; default: if (PHALCON_IS_NOT_EMPTY(&mime)) { zend_throw_exception_ex(phalcon_image_exception_ce, 0, "Installed GD does not support '%s' images", Z_STRVAL(mime)); } else { zend_throw_exception_ex(phalcon_image_exception_ce, 0, "Installed GD does not support such images"); } return; } if (Z_TYPE(image) != IS_RESOURCE) { assert(Z_TYPE(realpath) == IS_STRING); zend_throw_exception_ex(phalcon_image_exception_ce, 0, "Failed to create image from file '%s'", Z_STRVAL(realpath)); return; } phalcon_update_property_zval(getThis(), SL("_format"), &format); ZVAL_TRUE(&saveflag); PHALCON_CALL_FUNCTIONW(NULL, "imagesavealpha", &image, &saveflag); } else if (width && height) { PHALCON_CALL_FUNCTIONW(&image, "imagecreatetruecolor", width, height); if (Z_TYPE(image) != IS_RESOURCE) { PHALCON_THROW_EXCEPTION_STRW(phalcon_image_exception_ce, "imagecreatetruecolor() failed"); return; } ZVAL_TRUE(&blendmode); ZVAL_TRUE(&saveflag); PHALCON_CALL_FUNCTIONW(NULL, "imagealphablending", &image, &blendmode); PHALCON_CALL_FUNCTIONW(NULL, "imagesavealpha", &image, &saveflag); phalcon_update_property_zval(getThis(), SL("_realpath"), file); phalcon_update_property_zval(getThis(), SL("_width"), width); phalcon_update_property_zval(getThis(), SL("_height"), height); ZVAL_LONG(&type, 3); phalcon_update_property_zval(getThis(), SL("_type"), &type); ZVAL_STRING(&format, "png"); phalcon_update_property_zval(getThis(), SL("_format"), &format); ZVAL_STRING(&mime, "image/png"); phalcon_update_property_zval(getThis(), SL("_mime"), &mime); } else { PHALCON_CONCAT_SVS(&exception_message, "Failed to create image from file '", file, "'"); PHALCON_THROW_EXCEPTION_ZVALW(phalcon_image_exception_ce, &exception_message); return; } phalcon_update_property_zval(getThis(), SL("_image"), &image); }
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_Adapter_Stream, sendInternal){ zval *stream, *http, *option = NULL, *header, *handler, *base_uri, *url = NULL, *method, *useragent, *timeout; zval *fp = NULL, *meta = NULL, *wrapper_data, *bodystr = NULL, *response; 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); method = phalcon_fetch_nproperty_this(this_ptr, SL("_method"), PH_NOISY TSRMLS_CC); base_uri = phalcon_fetch_nproperty_this(this_ptr, SL("_base_uri"), PH_NOISY TSRMLS_CC); useragent = phalcon_fetch_nproperty_this(this_ptr, SL("_useragent"), PH_NOISY TSRMLS_CC); timeout = phalcon_fetch_nproperty_this(this_ptr, SL("_timeout"), PH_NOISY TSRMLS_CC); PHALCON_INIT_VAR(http); ZVAL_STRING(http, "http", 1); PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "method", 1); PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, method); if (PHALCON_IS_NOT_EMPTY(useragent)) { PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "User-Agent", 1); PHALCON_CALL_METHOD(NULL, header, "set", option, useragent); } PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, useragent); PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "timeout", 1); PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, timeout); PHALCON_CALL_METHOD(&url, base_uri, "build"); PHALCON_CALL_SELF(NULL, "buildBody"); PHALCON_INIT_VAR(handler); array_init_size(handler, 2); phalcon_array_append(&handler, this_ptr, PH_SEPARATE); add_next_index_stringl(handler, SL("errorHandler"), 1); PHALCON_CALL_FUNCTION(NULL, "set_error_handler", handler); PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "r", 1); PHALCON_CALL_FUNCTION(&fp, "fopen", url, option, PHALCON_GLOBAL(z_false), stream); PHALCON_CALL_FUNCTION(NULL, "restore_error_handler"); PHALCON_CALL_FUNCTION(&meta, "stream_get_meta_data", fp); PHALCON_CALL_FUNCTION(&bodystr, "stream_get_contents", fp); PHALCON_CALL_FUNCTION(NULL, "fclose", fp); PHALCON_INIT_VAR(response); object_init_ex(response, phalcon_http_client_response_ce); PHALCON_CALL_METHOD(NULL, response, "__construct"); if (phalcon_array_isset_string_fetch(&wrapper_data, meta, SS("wrapper_data"))) { PHALCON_CALL_METHOD(NULL, response, "setHeader", wrapper_data); } PHALCON_CALL_METHOD(NULL, response, "setbody", bodystr); RETURN_CTOR(response); }
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(); }
/** * 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); }