/**
* Return the lastest DI created
*
* @return Phalcon\DiInterface
*/
PHP_METHOD(Phalcon_DI, getDefault){
zval default_di = {}, dependency_injector = {};
phalcon_return_static_property_ce(&default_di, phalcon_di_ce, SL("_default"));
if (Z_TYPE(default_di) != IS_OBJECT) {
object_init_ex(&dependency_injector, phalcon_di_factorydefault_ce);
PHALCON_CALL_METHODW(NULL, &dependency_injector, "__construct");
RETURN_CTORW(&dependency_injector);
}
RETURN_CTORW(&default_di);
}
/**
* Creates a form registering it in the forms manager
*
* @param string $name
* @param object $entity
* @return Phalcon\Forms\Form
*/
PHP_METHOD(Phalcon_Forms_Manager, create){
zval *name = NULL, *entity = NULL, form = {};
phalcon_fetch_params(0, 0, 2, &name, &entity);
if (!name) {
name = &PHALCON_GLOBAL(z_null);
}
if (!entity) {
entity = &PHALCON_GLOBAL(z_null);
}
if (Z_TYPE_P(name) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_forms_exception_ce, "The form name must be string");
return;
}
object_init_ex(&form, phalcon_forms_form_ce);
PHALCON_CALL_METHODW(NULL, &form, "__construct", entity);
phalcon_update_property_array(getThis(), SL("_forms"), name, &form);
RETURN_CTORW(&form);
}
/**
* Returns a cached content
*
* @param int|string $keyName
* @param long $lifetime
* @return mixed
*/
PHP_METHOD(Phalcon_Cache_Backend_Memcache, get){
zval *key_name, *lifetime = NULL, memcache = {}, frontend = {}, prefix = {}, prefixed_key = {}, cached_content = {};
phalcon_fetch_params(0, 1, 1, &key_name, &lifetime);
phalcon_return_property(&memcache, getThis(), SL("_memcache"));
if (Z_TYPE(memcache) != IS_OBJECT) {
PHALCON_CALL_METHODW(&memcache, getThis(), "_connect");
}
phalcon_return_property(&frontend, getThis(), SL("_frontend"));
phalcon_return_property(&prefix, getThis(), SL("_prefix"));
PHALCON_CONCAT_VV(&prefixed_key, &prefix, key_name);
phalcon_update_property_zval(getThis(), SL("_lastKey"), &prefixed_key);
PHALCON_CALL_METHODW(&cached_content, &memcache, "get", &prefixed_key);
if (PHALCON_IS_FALSE(&cached_content)) {
RETURN_NULL();
}
if (phalcon_is_numeric(&cached_content)) {
RETURN_CTORW(&cached_content);
}
PHALCON_RETURN_CALL_METHOD(&frontend, "afterretrieve", &cached_content);
}
/**
* Get label for field
*
* @param string field
* @return string
*/
PHP_METHOD(Phalcon_Validation, getLabel) {
zend_bool _0;
zval *field, *labels = NULL, *value = NULL;
zephir_fetch_params(0, 1, 0, &field);
labels = zephir_fetch_nproperty_this(this_ptr, SL("_labels"), PH_NOISY_CC);
_0 = Z_TYPE_P(labels) == IS_ARRAY;
if (_0) {
_0 = Z_TYPE_P(field) != IS_ARRAY;
}
if (_0) {
if (zephir_array_isset_fetch(&value, labels, field, 1 TSRMLS_CC)) {
RETURN_CTORW(value);
}
} else if (Z_TYPE_P(field) == IS_ARRAY) {
zephir_fast_join_str(return_value, SL(", "), field TSRMLS_CC);
return;
}
RETVAL_ZVAL(field, 1, 0);
return;
}
/**
* Returns the complete location where the joined/filtered collection must be written
*
* @param string $basePath
* @return string
*/
PHP_METHOD(Phalcon_Assets_Collection, getRealTargetPath){
zval *base_path = NULL, *target_path, complete_path = {};
phalcon_fetch_params(0, 0, 1, &base_path);
if (!base_path) {
base_path = &PHALCON_GLOBAL(z_null);
}
target_path = phalcon_read_property(getThis(), SL("_targetPath"), PH_NOISY);
/**
* A base path for resources can be set in the assets manager
*/
PHALCON_CONCAT_VV(&complete_path, base_path, target_path);
/**
* Get the real template path, the target path can optionally don't exist
*/
if (phalcon_file_exists(&complete_path) == SUCCESS) {
phalcon_file_realpath(return_value, &complete_path);
return;
}
RETURN_CTORW(&complete_path);
}
/**
* Gets HTTP raw request body
*
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, getRawBody)
{
zval raw = {}, *zcontext = NULL;
zend_string *content;
php_stream_context *context;
php_stream *stream;
long int maxlen;
phalcon_read_property(&raw, getThis(), SL("_rawBody"), PH_NOISY);
if (Z_TYPE(raw) == IS_STRING) {
RETURN_CTORW(&raw);
}
context = php_stream_context_from_zval(zcontext, 0);
stream = php_stream_open_wrapper_ex("php://input", "rb", REPORT_ERRORS, NULL, context);
maxlen = PHP_STREAM_COPY_ALL;
if (!stream) {
RETURN_FALSE;
}
content = php_stream_copy_to_mem(stream, maxlen, 0);
if (content != NULL) {
RETVAL_STR(content);
phalcon_update_property_zval(getThis(), SL("_rawBody"), return_value);
} else {
RETVAL_FALSE;
}
php_stream_close(stream);
}
/**
* Resolves a service, the resolved service is stored in the DI, subsequent requests for this service will return the same instance
*
* @param string $name
* @param array $parameters
* @return mixed
*/
PHP_METHOD(Phalcon_DI, getShared){
zval *name, *parameters = NULL, *noerror = NULL, instance = {};
phalcon_fetch_params(0, 1, 2, &name, ¶meters, &noerror);
PHALCON_ENSURE_IS_STRING(name);
if (!parameters) {
parameters = &PHALCON_GLOBAL(z_null);
}
if (!noerror) {
noerror = &PHALCON_GLOBAL(z_null);
}
if (phalcon_isset_property_array(getThis(), SL("_sharedInstances"), name)) {
phalcon_return_property_array(&instance, getThis(), SL("_sharedInstances"), name);
phalcon_update_property_bool(getThis(), SL("_freshInstance"), 0);
} else {
PHALCON_CALL_SELFW(&instance, "get", name, parameters, noerror);
if (zend_is_true(&instance)) {
phalcon_update_property_bool(getThis(), SL("_freshInstance"), 1);
phalcon_update_property_array(getThis(), SL("_sharedInstances"), name, &instance);
}
}
RETURN_CTORW(&instance);
}
/**
* Internal get wrapper to filter
*
* @param string $name
* @param string|array $filters
* @param mixed $defaultValue
* @param boolean $notAllowEmpty
* @param boolean $noRecursive
* @return mixed
*/
PHP_METHOD(Phalcon_Http_Request, _get)
{
zval *data, *name, *filters, *default_value, *not_allow_empty, *norecursive;
zval value = {}, dependency_injector = {}, service = {}, filter = {}, filter_value = {};
phalcon_fetch_params(0, 6, 0, &data, &name, &filters, &default_value, ¬_allow_empty, &norecursive);
if (Z_TYPE_P(name) != IS_NULL) {
if (!phalcon_array_isset_fetch(&value, data, name, 0)) {
RETURN_CTORW(default_value);
}
} else {
PHALCON_CPY_WRT_CTOR(&value, data);
}
if (Z_TYPE_P(filters) != IS_NULL) {
phalcon_return_property(&filter, getThis(), SL("_filter"));
if (Z_TYPE(filter) != IS_OBJECT) {
PHALCON_CALL_METHODW(&dependency_injector, getThis(), "getdi");
if (Z_TYPE(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_http_request_exception_ce, "A dependency injection object is required to access the 'filter' service");
return;
}
PHALCON_STR(&service, ISV(filter));
PHALCON_CALL_METHODW(&filter, &dependency_injector, "getshared", &service);
PHALCON_VERIFY_INTERFACEW(&filter, phalcon_filterinterface_ce);
phalcon_update_property_zval(getThis(), SL("_filter"), &filter);
}
PHALCON_CALL_METHODW(&filter_value, &filter, "sanitize", &value, filters, norecursive);
if ((PHALCON_IS_EMPTY(&filter_value) && zend_is_true(not_allow_empty)) || PHALCON_IS_FALSE(&filter_value)) {
RETURN_CTORW(default_value);
}
RETURN_CTORW(&filter_value);
}
if (PHALCON_IS_EMPTY(&value) && zend_is_true(not_allow_empty)) {
RETURN_CTORW(default_value);
}
RETURN_CTORW(&value);
}
PHP_METHOD(Test_Properties_StaticProtectedProperties, getSomeNullInitial) {
zval *_0;
_0 = zephir_fetch_static_property_ce(test_properties_staticprotectedproperties_ce, SL("someNullInitial") TSRMLS_CC);
RETURN_CTORW(_0);
}
PHP_METHOD(Test_Concat, getTestProperty) {
zval *_0;
_0 = zephir_fetch_static_property_ce(test_concat_ce, SL("testProperty") TSRMLS_CC);
RETURN_CTORW(_0);
}
/**
* Return the latest DI created
*/
PHP_METHOD(Phalcon_Di, getDefault) {
zval *_0;
_0 = zephir_fetch_static_property_ce(phalcon_di_ce, SL("_default") TSRMLS_CC);
RETURN_CTORW(_0);
}
/**
* Returns the default Di container instance, or if one was not created
* then created a new instance and set the default
*
* @return DiInterface
*/
PHP_METHOD(Pdm_Di_Container, getDefault) {
zval *_0;
_0 = zephir_fetch_static_property_ce(pdm_di_container_ce, SL("defaultInstance") TSRMLS_CC);
RETURN_CTORW(_0);
}
/**
* @return boolean TRUE if the grant type requires a redirect_uri, FALSE if not
*/
PHP_METHOD(OAuth2_ResponseType_AuthorizationCode, enforceRedirect) {
zval *_0, *_1;
_0 = zephir_fetch_nproperty_this(this_ptr, SL("config"), PH_NOISY_CC);
zephir_array_fetch_string(&_1, _0, SL("enforce_redirect"), PH_NOISY | PH_READONLY, "oauth2/responsetype/authorizationcode.zep", 74 TSRMLS_CC);
RETURN_CTORW(_1);
}
PHP_METHOD(OAuth2_GrantType_JwtBearer, getUserId) {
zval *_0, *_1;
_0 = zephir_fetch_nproperty_this(this_ptr, SL("jwt"), PH_NOISY_CC);
zephir_array_fetch_string(&_1, _0, SL("sub"), PH_NOISY | PH_READONLY, "oauth2/granttype/jwtbearer.zep", 185 TSRMLS_CC);
RETURN_CTORW(_1);
}
/**
* Sets a service using a raw Phalcon\DI\Service definition
*
* @param string|Phalcon\DI\ServiceInterface $raw_definition_or_name
* @param Phalcon\DI\ServiceInterface $rawDefinition
* @return Phalcon\DI\ServiceInterface
*/
PHP_METHOD(Phalcon_DI, setService)
{
zval *name, *raw_definition;
phalcon_fetch_params(0, 1, 1, &name, &raw_definition);
phalcon_update_property_array(getThis(), SL("_services"), name, raw_definition);
RETURN_CTORW(raw_definition);
}
/**
* Gets active server name
*
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, getServerName){
zval *server, server_name = {};
server = phalcon_get_global_str(SL("_SERVER"));
if (phalcon_array_isset_fetch_str(&server_name, server, SL("SERVER_NAME"))) {
RETURN_CTORW(&server_name);
}
RETURN_STRING("localhost");
}
/**
* Returns the current resource in the iterator
*/
PHP_METHOD(Phalcon_Assets_Collection, current) {
zval *resource, *_0, *_1;
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_resources"), PH_NOISY_CC);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_position"), PH_NOISY_CC);
zephir_array_isset_fetch(&resource, _0, _1, 1 TSRMLS_CC);
RETURN_CTORW(resource);
}
/**
* Gets HTTP user agent used to made the request
*
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, getUserAgent){
zval *server, user_agent = {};
server = phalcon_get_global_str(SL("_SERVER"));
if (phalcon_array_isset_fetch_str(&user_agent, server, SL("HTTP_USER_AGENT"))) {
RETURN_CTORW(&user_agent);
}
RETURN_EMPTY_STRING();
}
/**
* Gets active server address IP
*
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, getServerAddress){
zval *server, server_addr = {};
server = phalcon_get_global_str(SL("_SERVER"));
if (phalcon_array_isset_fetch_str(&server_addr, server, SL("SERVER_ADDR"))) {
RETURN_CTORW(&server_addr);
}
RETURN_STRING("127.0.0.1");
}
/**
* Gets most possible client IPv4 Address. This method search in $_SERVER['REMOTE_ADDR'] and optionally in $_SERVER['HTTP_X_FORWARDED_FOR']
*
* @param boolean $trustForwardedHeader
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, getClientAddress){
zval *trust_forwarded_header = NULL, *_SERVER, address = {}, addresses = {}, first = {};
phalcon_fetch_params(0, 0, 1, &trust_forwarded_header);
if (!trust_forwarded_header) {
trust_forwarded_header = &PHALCON_GLOBAL(z_false);
}
_SERVER = phalcon_get_global_str(SL("_SERVER"));
/**
* Proxies use this IP
*/
if (zend_is_true(trust_forwarded_header)) {
if (!phalcon_array_isset_fetch_str(&address, _SERVER, SL("HTTP_X_FORWARDED_FOR"))) {
if (!phalcon_array_isset_fetch_str(&address, _SERVER, SL("REMOTE_ADDR"))) {
phalcon_array_fetch_str(&address, _SERVER, SL("REMOTE_ADDR"), PH_NOISY);
}
}
} else if (!phalcon_array_isset_fetch_str(&address, _SERVER, SL("REMOTE_ADDR"))) {
phalcon_array_fetch_str(&address, _SERVER, SL("REMOTE_ADDR"), PH_NOISY);
}
if (Z_TYPE(address) == IS_STRING) {
if (phalcon_memnstr_str(&address, SL(","))) {
/**
* The client address has multiples parts, only return the first part
*/
phalcon_fast_explode_str(&addresses, SL(","), &address);
phalcon_array_fetch_long(&first, &addresses, 0, PH_NOISY);
RETURN_CTORW(&first);
}
RETURN_CTORW(&address);
}
RETURN_FALSE;
}
/**
* Retrieve the URI path
*
* @return string
*/
PHP_METHOD(Phalcon_Http_Uri, getPath)
{
zval parts = {}, value = {};
phalcon_read_property(&parts, getThis(), SL("_parts"), PH_NOISY);
if (!phalcon_array_isset_fetch_str(&value, &parts, SL("path"))) {
RETURN_NULL();
}
RETURN_CTORW(&value);
}
PHP_METHOD(Phalcon_Http_Uri, resolve)
{
zval *uri, self = {};
phalcon_fetch_params(0, 1, 0, &uri);
object_init_ex(&self, phalcon_http_uri_ce);
PHALCON_CALL_METHODW(NULL, &self, "__construct", getThis());
PHALCON_CALL_METHODW(NULL, &self, "extend", uri);
RETURN_CTORW(&self);
}
/**
* Returns the order clause in the criteria
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, getOrder) {
zval *order = NULL, *_0;
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_params"), PH_NOISY_CC);
if (zephir_array_isset_string_fetch(&order, _0, SS("order"), 1 TSRMLS_CC)) {
RETURN_CTORW(order);
}
RETURN_NULL();
}
/**
* Returns the conditions parameter in the criteria
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, getConditions) {
zval *conditions = NULL, *_0;
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_params"), PH_NOISY_CC);
if (zephir_array_isset_string_fetch(&conditions, _0, SS("conditions"), 1 TSRMLS_CC)) {
RETURN_CTORW(conditions);
}
RETURN_NULL();
}
PHP_METHOD(Test_Concat, getTestProperty) {
zval _0;
ZEPHIR_INIT_THIS();
ZVAL_UNDEF(&_0);
zephir_read_static_property_ce(&_0, test_concat_ce, SL("testProperty"), PH_NOISY_CC | PH_READONLY);
RETURN_CTORW(_0);
}
/**
* Returns the DependencyInjector container
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, getDI) {
zval *dependencyInjector = NULL, *_0;
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_params"), PH_NOISY_CC);
if (zephir_array_isset_string_fetch(&dependencyInjector, _0, SS("di"), 1 TSRMLS_CC)) {
RETURN_CTORW(dependencyInjector);
}
RETURN_NULL();
}
/**
* Returns the having clause in the criteria
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, getHaving) {
zval *having = NULL, *_0;
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_params"), PH_NOISY_CC);
if (zephir_array_isset_string_fetch(&having, _0, SS("having"), 1 TSRMLS_CC)) {
RETURN_CTORW(having);
}
RETURN_NULL();
}
PHP_METHOD(Test_Properties_StaticProtectedProperties, getSomeNull) {
zval _0;
ZEPHIR_INIT_THIS();
ZVAL_UNDEF(&_0);
zephir_read_static_property_ce(&_0, test_properties_staticprotectedproperties_ce, SL("someNull"), PH_NOISY_CC | PH_READONLY);
RETURN_CTORW(_0);
}
/**
* Returns the group clause in the criteria
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, getGroupBy) {
zval *group = NULL, *_0;
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_params"), PH_NOISY_CC);
if (zephir_array_isset_string_fetch(&group, _0, SS("group"), 1 TSRMLS_CC)) {
RETURN_CTORW(group);
}
RETURN_NULL();
}
/**
* Returns the limit parameter in the criteria, which will be
* an integer if limit was set without an offset,
* an array with 'number' and 'offset' keys if an offset was set with the limit,
* or null if limit has not been set.
*
* @return int|array|null
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, getLimit) {
zval *limit = NULL, *_0;
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_params"), PH_NOISY_CC);
if (zephir_array_isset_string_fetch(&limit, _0, SS("limit"), 1 TSRMLS_CC)) {
RETURN_CTORW(limit);
}
RETURN_NULL();
}
