/**
* Magic __isset method
*
* @param string $key
* @return boolean
*/
PHP_METHOD(Phalcon_Http_Uri, __isset){
zval *key, parts = {};
phalcon_fetch_params(0, 1, 0, &key);
phalcon_read_property(&parts, getThis(), SL("_parts"), PH_NOISY);
RETURN_BOOL(phalcon_array_isset(&parts, key));
}
/**
* Check if a model has certain attribute
*
* @param Phalcon\Mvc\ModelInterface $model
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, hasAttribute){
zval *model, *attribute, *column_map, *meta_data;
zval *data_types;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &model, &attribute) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(attribute) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Attribute must be a string");
return;
}
PHALCON_INIT_VAR(column_map);
PHALCON_CALL_METHOD_PARAMS_1(column_map, this_ptr, "getreversecolumnmap", model, PH_NO_CHECK);
if (Z_TYPE_P(column_map) == IS_ARRAY) {
eval_int = phalcon_array_isset(column_map, attribute);
if (eval_int) {
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
} else {
PHALCON_INIT_VAR(meta_data);
PHALCON_CALL_METHOD_PARAMS_1(meta_data, this_ptr, "readmetadata", model, PH_NO_CHECK);
PHALCON_INIT_VAR(data_types);
phalcon_array_fetch_long(&data_types, meta_data, 4, PH_NOISY_CC);
eval_int = phalcon_array_isset(data_types, attribute);
if (eval_int) {
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
}
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
/**
* Gets hasMany related records from a model
*
* @param string $method
* @param string $modelName
* @param string $modelRelation
* @param Phalcon\Mvc\Model $record
* @param array $parameters
* @return Phalcon\Mvc\Model\Resultset
*/
PHP_METHOD(Phalcon_Mvc_Model_Manager, getHasManyRecords){
zval *method, *model_name, *model_relation, *record;
zval *parameters = NULL, *has_many, *relation, *records;
zval *r0 = NULL, *r1 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzzz|z", &method, &model_name, &model_relation, &record, ¶meters) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!parameters) {
PHALCON_INIT_NVAR(parameters);
}
PHALCON_INIT_VAR(has_many);
phalcon_read_property(&has_many, this_ptr, SL("_hasMany"), PH_NOISY_CC);
eval_int = phalcon_array_isset(has_many, model_name);
if (eval_int) {
PHALCON_INIT_VAR(r0);
phalcon_array_fetch(&r0, has_many, model_name, PH_NOISY_CC);
eval_int = phalcon_array_isset(r0, model_relation);
if (!eval_int) {
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_INIT_VAR(r1);
phalcon_array_fetch(&r1, has_many, model_name, PH_NOISY_CC);
PHALCON_INIT_VAR(relation);
phalcon_array_fetch(&relation, r1, model_relation, PH_NOISY_CC);
PHALCON_INIT_VAR(records);
PHALCON_CALL_METHOD_PARAMS_4(records, this_ptr, "_getrelationrecords", relation, method, record, parameters, PH_NO_CHECK);
RETURN_CCTOR(records);
}
/**
* Writes meta-data for certain model using a MODEL_* constant
*
* @param Phalcon\Mvc\ModelInterface $model
* @param int $index
* @param mixed $data
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, writeMetaDataIndex){
zval *model, *index, *data, *table, *schema, *key, *meta_data = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &model, &index, &data) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(model) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "A model instance is required to retrieve the meta-data");
return;
}
if (Z_TYPE_P(index) != IS_LONG) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Index must be a valid integer constant");
return;
}
if (Z_TYPE_P(data) != IS_ARRAY) {
if (Z_TYPE_P(data) != IS_STRING) {
if (Z_TYPE_P(data) != IS_BOOL) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Invalid data for index");
return;
}
}
}
PHALCON_INIT_VAR(table);
PHALCON_CALL_METHOD(table, model, "getsource", PH_NO_CHECK);
PHALCON_INIT_VAR(schema);
PHALCON_CALL_METHOD(schema, model, "getschema", PH_NO_CHECK);
PHALCON_INIT_VAR(key);
PHALCON_CONCAT_VV(key, schema, table);
PHALCON_INIT_VAR(meta_data);
phalcon_read_property(&meta_data, this_ptr, SL("_metaData"), PH_NOISY_CC);
eval_int = phalcon_array_isset(meta_data, key);
if (!eval_int) {
PHALCON_CALL_METHOD_PARAMS_4_NORETURN(this_ptr, "_initialize", model, key, table, schema, PH_NO_CHECK);
PHALCON_INIT_NVAR(meta_data);
phalcon_read_property(&meta_data, this_ptr, SL("_metaData"), PH_NOISY_CC);
}
phalcon_array_update_multi_2(&meta_data, key, index, &data, 0 TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_metaData"), meta_data TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Returns the connection related to a model
*
* @param Phalcon\Mvc\CollectionInterface $model
* @return Phalcon\Db\AdapterInterface
*/
PHP_METHOD(Phalcon_Mvc_Collection_Manager, getConnection){
zval *model, *service = NULL, *connection_services;
zval *entity_name, *dependency_injector, *connection;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &model);
if (Z_TYPE_P(model) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_collection_exception_ce, "A valid collection instance is required");
return;
}
PHALCON_INIT_VAR(service);
ZVAL_STRING(service, "mongo", 1);
PHALCON_OBS_VAR(connection_services);
phalcon_read_property_this(&connection_services, this_ptr, SL("_connectionServices"), PH_NOISY_CC);
if (Z_TYPE_P(connection_services) == IS_ARRAY) {
PHALCON_INIT_VAR(entity_name);
phalcon_get_class(entity_name, model, 1 TSRMLS_CC);
/**
* Check if the model has a custom connection service
*/
if (phalcon_array_isset(connection_services, entity_name)) {
PHALCON_OBS_NVAR(service);
phalcon_array_fetch(&service, connection_services, entity_name, 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_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "A dependency injector container is required to obtain the services related to the ORM");
return;
}
/**
* Request the connection service from the DI
*/
PHALCON_INIT_VAR(connection);
PHALCON_CALL_METHOD_PARAMS_1(connection, dependency_injector, "getshared", service);
if (Z_TYPE_P(connection) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Invalid injected connection service");
return;
}
RETURN_CCTOR(connection);
}
/**
* Checks whether $_SERVER superglobal has certain index
*
* @param string $name
* @return mixed
*/
PHP_METHOD(Phalcon_Http_Request, hasServer){
zval *name, *_SERVER;
phalcon_fetch_params(0, 1, 0, &name);
phalcon_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC);
if (phalcon_array_isset(_SERVER, name)) {
RETURN_TRUE;
}
RETURN_FALSE;
}
/**
* Checks whether $_GET superglobal has certain index
*
* @param string $name
* @return boolean
*/
PHP_METHOD(Phalcon_Http_Request, hasQuery){
zval *name, *_GET;
phalcon_fetch_params(0, 1, 0, &name);
phalcon_get_global(&_GET, SS("_GET") TSRMLS_CC);
if (phalcon_array_isset(_GET, name)) {
RETURN_TRUE;
}
RETURN_FALSE;
}
/**
* Receives events generated in the models and dispatches them to a events-manager if available
* Notify the behaviors that are listening in the model
*
* @param string $eventName
* @param Phalcon\Mvc\CollectionInterface $model
*/
PHP_METHOD(Phalcon_Mvc_Collection_Manager, notifyEvent){
zval *event_name, *model, *status = NULL, *events_manager;
zval *fire_event_name = NULL, *custom_events_manager;
zval *entity_name;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &event_name, &model);
PHALCON_INIT_VAR(status);
/**
* Dispatch events to the global events manager
*/
PHALCON_OBS_VAR(events_manager);
phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(fire_event_name);
PHALCON_CONCAT_SV(fire_event_name, "collection:", event_name);
PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", fire_event_name, model);
if (PHALCON_IS_FALSE(status)) {
RETURN_CCTOR(status);
}
}
/**
* A model can has a specific events manager for it
*/
PHALCON_OBS_VAR(custom_events_manager);
phalcon_read_property_this(&custom_events_manager, this_ptr, SL("_customEventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(custom_events_manager) == IS_ARRAY) {
PHALCON_INIT_VAR(entity_name);
phalcon_get_class(entity_name, model, 1 TSRMLS_CC);
if (phalcon_array_isset(custom_events_manager, entity_name)) {
PHALCON_INIT_NVAR(fire_event_name);
PHALCON_CONCAT_SV(fire_event_name, "collection:", event_name);
PHALCON_INIT_NVAR(status);
PHALCON_CALL_METHOD_PARAMS_2(status, custom_events_manager, "fire", fire_event_name, model);
if (PHALCON_IS_FALSE(status)) {
RETURN_CCTOR(status);
}
}
}
RETURN_CCTOR(status);
}
/**
* bool \Phalcon\Flash\Session::has(string $type)
*
* @see https://github.com/phalcon/cphalcon/issues/1342
*/
PHP_METHOD(Phalcon_Flash_Session, has) {
zval *type, *messages = NULL;
phalcon_fetch_params(0, 0, 1, &type);
PHALCON_MM_GROW();
PHALCON_CALL_METHOD(&messages, this_ptr, "_getsessionmessages", PHALCON_GLOBAL(z_false));
RETVAL_BOOL(phalcon_array_isset(messages, type));
PHALCON_MM_RESTORE();
}
/**
* Adds a role to the ACL list. Second parameter allows inheriting access data from other existing role
*
* Example:
* <code>
* $acl->addRole(new Phalcon\Acl\Role('administrator'), 'consultant');
* $acl->addRole('administrator', 'consultant');
* </code>
*
* @param Phalcon\Acl\RoleInterface $role
* @param array|string $accessInherits
* @return boolean
*/
PHP_METHOD(Phalcon_Acl_Adapter_Memory, addRole){
zval *role, *access_inherits = NULL, *role_name = NULL, *object = NULL;
zval *roles_names, *exists, *default_access;
zval *key, *success;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &role, &access_inherits);
if (!access_inherits) {
PHALCON_INIT_VAR(access_inherits);
}
if (Z_TYPE_P(role) == IS_OBJECT) {
PHALCON_INIT_VAR(role_name);
phalcon_call_method(role_name, role, "getname");
PHALCON_CPY_WRT(object, role);
} else {
PHALCON_CPY_WRT(role_name, role);
PHALCON_INIT_NVAR(object);
object_init_ex(object, phalcon_acl_role_ce);
phalcon_call_method_p1_noret(object, "__construct", role);
}
PHALCON_OBS_VAR(roles_names);
phalcon_read_property_this(&roles_names, this_ptr, SL("_rolesNames"), PH_NOISY_CC);
if (phalcon_array_isset(roles_names, role_name)) {
RETURN_MM_FALSE;
}
PHALCON_INIT_VAR(exists);
ZVAL_BOOL(exists, 1);
phalcon_update_property_array_append(this_ptr, SL("_roles"), object TSRMLS_CC);
phalcon_update_property_array(this_ptr, SL("_rolesNames"), role_name, exists TSRMLS_CC);
PHALCON_OBS_VAR(default_access);
phalcon_read_property_this(&default_access, this_ptr, SL("_defaultAccess"), PH_NOISY_CC);
PHALCON_INIT_VAR(key);
PHALCON_CONCAT_VS(key, role_name, "!*!*");
phalcon_update_property_array(this_ptr, SL("_access"), key, default_access TSRMLS_CC);
if (Z_TYPE_P(access_inherits) != IS_NULL) {
PHALCON_INIT_VAR(success);
phalcon_call_method_p2(success, this_ptr, "addinherit", role_name, access_inherits);
RETURN_CCTOR(success);
}
RETURN_MM_TRUE;
}
/**
* Reads meta-data for certain model using a MODEL_* constant
*
*<code>
* print_r($metaData->writeColumnMapIndex(new Robots(), MetaData::MODELS_REVERSE_COLUMN_MAP, array('leName' => 'name')));
*</code>
*
* @param Phalcon\Mvc\ModelInterface $model
* @param int $index
* @return array
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, readMetaDataIndex){
zval *model, *index, *table, *schema, *class_name;
zval *key, *meta_data = NULL, *meta_data_index, *attributes;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &model, &index) == FAILURE) {
RETURN_MM_NULL();
}
if (Z_TYPE_P(model) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "A model instance is required to retrieve the meta-data");
return;
}
if (Z_TYPE_P(index) != IS_LONG) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Index must be a valid integer constant");
return;
}
PHALCON_INIT_VAR(table);
PHALCON_CALL_METHOD(table, model, "getsource");
PHALCON_INIT_VAR(schema);
PHALCON_CALL_METHOD(schema, model, "getschema");
PHALCON_INIT_VAR(class_name);
phalcon_get_class(class_name, model, 1 TSRMLS_CC);
/**
* Unique key for meta-data is created using class-name-schema-table
*/
PHALCON_INIT_VAR(key);
PHALCON_CONCAT_VSVV(key, class_name, "-", schema, table);
PHALCON_OBS_VAR(meta_data);
phalcon_read_property(&meta_data, this_ptr, SL("_metaData"), PH_NOISY_CC);
if (!phalcon_array_isset(meta_data, key)) {
PHALCON_CALL_METHOD_PARAMS_4_NORETURN(this_ptr, "_initialize", model, key, table, schema);
PHALCON_OBS_NVAR(meta_data);
phalcon_read_property(&meta_data, this_ptr, SL("_metaData"), PH_NOISY_CC);
}
PHALCON_OBS_VAR(meta_data_index);
phalcon_array_fetch(&meta_data_index, meta_data, key, PH_NOISY_CC);
PHALCON_OBS_VAR(attributes);
phalcon_array_fetch(&attributes, meta_data_index, index, PH_NOISY_CC);
RETURN_CCTOR(attributes);
}
/**
* Check if the current element in the iterator is valid
*
* @return boolean
*/
PHP_METHOD(Phalcon_Assets_Collection, valid){
zval *position, *resources;
position = phalcon_read_property(getThis(), SL("_position"), PH_NOISY);
resources = phalcon_read_property(getThis(), SL("_resources"), PH_NOISY);
if (phalcon_array_isset(resources, position)) {
RETURN_TRUE;
}
RETURN_FALSE;
}
/**
* Gets a value from the the internal related entity or from the default value
*
* @param string $name
* @return mixed
*/
PHP_METHOD(Phalcon_Forms_Form, getValue){
zval *name, *entity, *method, *value = NULL, *data;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &name) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_OBS_VAR(entity);
phalcon_read_property(&entity, this_ptr, SL("_entity"), PH_NOISY_CC);
if (Z_TYPE_P(entity) == IS_OBJECT) {
/**
* Check if the entity has a getter
*/
PHALCON_INIT_VAR(method);
PHALCON_CONCAT_SV(method, "get", name);
if (phalcon_method_exists(entity, method TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD(value, entity, Z_STRVAL_P(method));
RETURN_CCTOR(value);
}
/**
* Check if the entity has a public property
*/
if (phalcon_isset_property_zval(entity, name TSRMLS_CC)) {
PHALCON_OBS_NVAR(value);
phalcon_read_property_zval(&value, entity, name, PH_NOISY_CC);
RETURN_CCTOR(value);
}
}
PHALCON_OBS_VAR(data);
phalcon_read_property(&data, this_ptr, SL("_data"), PH_NOISY_CC);
if (Z_TYPE_P(data) == IS_ARRAY) {
/**
* Check if the data is in the data array
*/
if (phalcon_array_isset(data, name)) {
PHALCON_OBS_NVAR(value);
phalcon_array_fetch(&value, data, name, PH_NOISY_CC);
RETURN_CCTOR(value);
}
}
RETURN_MM_NULL();
}
/**
* Gets variable from $_POST superglobal applying filters if needed
*
* @param string $name
* @param string|array $filters
* @return mixed
*/
PHP_METHOD(Phalcon_Http_Request, getPost){
zval *name = NULL, *filters = NULL, *value = NULL, *dependency_injector = NULL;
zval *filter = NULL, *sanitized_value = NULL;
zval *g0 = NULL;
zval *c0 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &name, &filters) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!filters) {
PHALCON_ALLOC_ZVAL_MM(filters);
ZVAL_NULL(filters);
}
phalcon_get_global(&g0, SL("_POST")+1 TSRMLS_CC);
eval_int = phalcon_array_isset(g0, name);
if (eval_int) {
PHALCON_INIT_VAR(value);
phalcon_array_fetch(&value, g0, name, PH_NOISY_CC);
if (zend_is_true(filters)) {
PHALCON_INIT_VAR(dependency_injector);
phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (!zend_is_true(dependency_injector)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_http_request_exception_ce, "A dependency injection object is required to access the 'filter' service");
return;
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "filter", 1);
PHALCON_INIT_VAR(filter);
PHALCON_CALL_METHOD_PARAMS_1(filter, dependency_injector, "getshared", c0, PH_NO_CHECK);
PHALCON_INIT_VAR(sanitized_value);
PHALCON_CALL_METHOD_PARAMS_2(sanitized_value, filter, "sanitize", value, filters, PH_NO_CHECK);
RETURN_CCTOR(sanitized_value);
} else {
RETURN_CCTOR(value);
}
}
PHALCON_MM_RESTORE();
RETURN_NULL();
}
/**
* Returns the messages in the session flasher
*
* @param string $type
* @param boolean $remove
* @return array
*/
PHP_METHOD(Phalcon_Flash_Session, getMessages){
zval *type = NULL, *remove = NULL, *messages, *return_messages;
zval *do_remove;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 2, &type, &remove);
if (!type) {
PHALCON_INIT_VAR(type);
}
if (!remove) {
PHALCON_INIT_VAR(remove);
ZVAL_BOOL(remove, 1);
}
if (Z_TYPE_P(type) != IS_NULL) {
PHALCON_INIT_VAR(do_remove);
ZVAL_FALSE(do_remove);
}
else {
do_remove = remove;
}
PHALCON_INIT_VAR(messages);
phalcon_call_method_p1(messages, this_ptr, "_getsessionmessages", do_remove);
if (Z_TYPE_P(messages) == IS_ARRAY) {
if (likely(Z_TYPE_P(type) != IS_NULL)) {
if (phalcon_array_isset(messages, type)) {
PHALCON_OBS_VAR(return_messages);
phalcon_array_fetch(&return_messages, messages, type, PH_NOISY);
RETVAL_ZVAL(return_messages, 1, 0);
if (zend_is_true(remove)) {
phalcon_array_unset(&messages, type, 0);
phalcon_call_method_p1_noret(this_ptr, "_setsessionmessages", messages);
}
PHALCON_MM_RESTORE();
return;
}
RETURN_MM_EMPTY_ARRAY();
}
RETURN_CCTOR(messages);
}
RETURN_MM_EMPTY_ARRAY();
}
/**
* Gets belongsTo related records from a model
*
* @param string $method
* @param string $modelName
* @param string $modelRelation
* @param Phalcon\Mvc\Model $record
* @return Phalcon\Mvc\Model\Resultset
*/
PHP_METHOD(Phalcon_Mvc_Model_Manager, getBelongsToRecords){
zval *method = NULL, *model_name = NULL, *model_relation = NULL, *record = NULL;
zval *belongs_to = NULL, *relation = NULL, *records = NULL;
zval *r0 = NULL, *r1 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzzz", &method, &model_name, &model_relation, &record) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(belongs_to);
phalcon_read_property(&belongs_to, this_ptr, SL("_belongsTo"), PH_NOISY_CC);
eval_int = phalcon_array_isset(belongs_to, model_name);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch(&r0, belongs_to, model_name, PH_NOISY_CC);
eval_int = phalcon_array_isset(r0, model_relation);
if (!eval_int) {
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch(&r1, belongs_to, model_name, PH_NOISY_CC);
PHALCON_INIT_VAR(relation);
phalcon_array_fetch(&relation, r1, model_relation, PH_NOISY_CC);
PHALCON_INIT_VAR(records);
PHALCON_CALL_METHOD_PARAMS_3(records, this_ptr, "_getrelationrecords", relation, method, record, PH_NO_CHECK);
RETURN_CCTOR(records);
}
/**
* Reads meta-data for certain model using a MODEL_* constant
*
* @param Phalcon\Mvc\Model $model
* @param int $index
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, readMetaDataIndex){
zval *model, *index, *table, *schema, *key, *meta_data = NULL;
zval *attributes;
zval *r0 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &model, &index) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(model) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "A model instance is required to retrieve the meta-data");
return;
}
if (Z_TYPE_P(index) != IS_LONG) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Index must be a valid integer constant");
return;
}
PHALCON_INIT_VAR(table);
PHALCON_CALL_METHOD(table, model, "getsource", PH_NO_CHECK);
PHALCON_INIT_VAR(schema);
PHALCON_CALL_METHOD(schema, model, "getschema", PH_NO_CHECK);
PHALCON_INIT_VAR(key);
PHALCON_CONCAT_VV(key, schema, table);
PHALCON_INIT_VAR(meta_data);
phalcon_read_property(&meta_data, this_ptr, SL("_metaData"), PH_NOISY_CC);
eval_int = phalcon_array_isset(meta_data, key);
if (!eval_int) {
PHALCON_CALL_METHOD_PARAMS_4_NORETURN(this_ptr, "_initializemetadata", model, key, table, schema, PH_NO_CHECK);
PHALCON_INIT_NVAR(meta_data);
phalcon_read_property(&meta_data, this_ptr, SL("_metaData"), PH_NOISY_CC);
}
PHALCON_INIT_VAR(r0);
phalcon_array_fetch(&r0, meta_data, key, PH_NOISY_CC);
PHALCON_INIT_VAR(attributes);
phalcon_array_fetch(&attributes, r0, index, PH_NOISY_CC);
RETURN_CCTOR(attributes);
}
/**
* Check whether a model is already initialized
*
* @param string $modelName
* @return bool
*/
PHP_METHOD(Phalcon_Mvc_Collection_Manager, isInitialized){
zval *model_name, *initialized, *lowercased;
phalcon_fetch_params(0, 1, 0, &model_name);
initialized = phalcon_fetch_nproperty_this(this_ptr, SL("_initialized"), PH_NOISY TSRMLS_CC);
ALLOC_INIT_ZVAL(lowercased);
phalcon_fast_strtolower(lowercased, model_name);
RETVAL_BOOL(phalcon_array_isset(initialized, lowercased));
zval_ptr_dtor(&lowercased);
}
/**
* Returns the translation related to the given key
*
* @param string $index
* @param array $placeholders
* @return string
*/
PHP_METHOD(Phalcon_Translate_Adapter_NativeArray, query){
zval *index, *placeholders = NULL, *translate, *translation = NULL;
zval *value = NULL, *key = NULL, *key_placeholder = NULL, *replaced = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &index, &placeholders);
if (!placeholders) {
PHALCON_INIT_VAR(placeholders);
}
PHALCON_OBS_VAR(translate);
phalcon_read_property_this(&translate, this_ptr, SL("_translate"), PH_NOISY_CC);
if (phalcon_array_isset(translate, index)) {
PHALCON_OBS_VAR(translation);
phalcon_array_fetch(&translation, translate, index, PH_NOISY);
if (Z_TYPE_P(placeholders) == IS_ARRAY) {
if (phalcon_fast_count_ev(placeholders TSRMLS_CC)) {
phalcon_is_iterable(placeholders, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(key, ah0, hp0);
PHALCON_GET_HVALUE(value);
PHALCON_INIT_NVAR(key_placeholder);
PHALCON_CONCAT_SVS(key_placeholder, "%", key, "%");
PHALCON_INIT_NVAR(replaced);
phalcon_fast_str_replace(replaced, key_placeholder, value, translation);
PHALCON_CPY_WRT(translation, replaced);
zend_hash_move_forward_ex(ah0, &hp0);
}
}
}
RETURN_CCTOR(translation);
}
RETURN_CCTOR(index);
}
/**
* Gets HTTP header from request data
*
* @param string $header
* @return string
*/
PHP_METHOD(Phalcon_Request, getHeader){
zval *header = NULL;
zval *g0 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &header) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
phalcon_get_global(&g0, "_SERVER", sizeof("_SERVER") TSRMLS_CC);
eval_int = phalcon_array_isset(g0, header);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch(&r0, g0, header, PHALCON_NOISY TSRMLS_CC);
PHALCON_RETURN_CHECK_CTOR(r0);
} else {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CONCAT_LEFT(r1, "HTTP_", header);
eval_int = phalcon_array_isset(g0, r1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CONCAT_LEFT(r2, "HTTP_", header);
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_array_fetch(&r3, g0, r2, PHALCON_NOISY TSRMLS_CC);
PHALCON_RETURN_CHECK_CTOR(r3);
}
}
PHALCON_MM_RESTORE();
RETURN_STRING("", 1);
}
/**
* Gets HTTP header from request data
*
* @param string $header
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, getHeader){
zval *header, *_SERVER, *server_value = NULL, *key;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &header);
phalcon_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC);
if (phalcon_array_isset(_SERVER, header)) {
PHALCON_OBS_VAR(server_value);
phalcon_array_fetch(&server_value, _SERVER, header, PH_NOISY);
RETURN_CCTOR(server_value);
} else {
PHALCON_INIT_VAR(key);
PHALCON_CONCAT_SV(key, "HTTP_", header);
if (phalcon_array_isset(_SERVER, key)) {
PHALCON_OBS_NVAR(server_value);
phalcon_array_fetch(&server_value, _SERVER, key, PH_NOISY);
RETURN_CCTOR(server_value);
}
}
RETURN_MM_EMPTY_STRING();
}
/**
* Every helper calls this function to check whether a component has a predefined
* value using Phalcon\Tag::setDefault or value from $_POST
*
* @param string $name
* @return mixed
*/
PHP_METHOD(Phalcon_Tag, getValue){
zval *name, *display_values = NULL, *default_value;
zval *post = NULL, *post_name;
zval *g0 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &name) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_OBSERVE_VAR(display_values);
phalcon_read_static_property(&display_values, SL("phalcon\\tag"), SL("_displayValues") TSRMLS_CC);
eval_int = phalcon_array_isset(display_values, name);
if (eval_int) {
PHALCON_INIT_VAR(default_value);
phalcon_array_fetch(&default_value, display_values, name, PH_NOISY_CC);
RETURN_CCTOR(default_value);
} else {
phalcon_get_global(&g0, SL("_POST")+1 TSRMLS_CC);
PHALCON_CPY_WRT(post, g0);
eval_int = phalcon_array_isset(post, name);
if (eval_int) {
PHALCON_INIT_VAR(post_name);
phalcon_array_fetch(&post_name, post, name, PH_NOISY_CC);
RETURN_CCTOR(post_name);
}
}
PHALCON_MM_RESTORE();
}
/**
* Adds a resource to the ACL list
*
* Access names can be a particular action, by example
* search, update, delete, etc or a list of them
*
* Example:
* <code>
* //Add a resource to the the list allowing access to an action
* $acl->addResource(new Phalcon\Acl\Resource('customers'), 'search');
* $acl->addResource('customers', 'search');
*
* //Add a resource with an access list
* $acl->addResource(new Phalcon\Acl\Resource('customers'), array('create', 'search'));
* $acl->addResource('customers', array('create', 'search'));
* </code>
*
* @param Phalcon\Acl\Resource $resource
* @param array $accessList
* @return boolean
*/
PHP_METHOD(Phalcon_Acl_Adapter_Memory, addResource){
zval *resource, *access_list = NULL, *resource_name = NULL;
zval *object = NULL, *resources_names, *empty_arr, *status;
zval *t0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &resource, &access_list) == FAILURE) {
RETURN_MM_NULL();
}
if (!access_list) {
PHALCON_INIT_VAR(access_list);
}
if (Z_TYPE_P(resource) == IS_OBJECT) {
PHALCON_INIT_VAR(resource_name);
PHALCON_CALL_METHOD(resource_name, resource, "getname");
PHALCON_CPY_WRT(object, resource);
} else {
PHALCON_CPY_WRT(resource_name, resource);
PHALCON_INIT_VAR(object);
object_init_ex(object, phalcon_acl_resource_ce);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(object, "__construct", resource_name);
}
PHALCON_OBS_VAR(resources_names);
phalcon_read_property(&resources_names, this_ptr, SL("_resourcesNames"), PH_NOISY_CC);
if (!phalcon_array_isset(resources_names, resource_name)) {
phalcon_update_property_array_append(this_ptr, SL("_resources"), object TSRMLS_CC);
PHALCON_INIT_VAR(empty_arr);
array_init(empty_arr);
phalcon_update_property_array(this_ptr, SL("_accessList"), resource_name, empty_arr TSRMLS_CC);
PHALCON_INIT_VAR(t0);
ZVAL_BOOL(t0, 1);
phalcon_update_property_array(this_ptr, SL("_resourcesNames"), resource_name, t0 TSRMLS_CC);
}
PHALCON_INIT_VAR(status);
PHALCON_CALL_METHOD_PARAMS_2(status, this_ptr, "addresourceaccess", resource_name, access_list);
RETURN_CCTOR(status);
}
/**
* Check whether resource exist in the resources list
*
* @param string $resourceName
* @return boolean
*/
PHP_METHOD(Phalcon_Acl_Adapter_Memory, isResource){
zval *resource_name, *resources_names;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &resource_name);
PHALCON_OBS_VAR(resources_names);
phalcon_read_property_this(&resources_names, this_ptr, SL("_resourcesNames"), PH_NOISY_CC);
if (phalcon_array_isset(resources_names, resource_name)) {
RETURN_MM_TRUE;
}
RETURN_MM_FALSE;
}
/**
* Gets variable from $_SERVER superglobal
*
* @param string $name
* @return mixed
*/
PHP_METHOD(Phalcon_Http_Request, getServer){
zval *name, *_SERVER, *server_value;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &name);
phalcon_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC);
if (phalcon_array_isset(_SERVER, name)) {
PHALCON_OBS_VAR(server_value);
phalcon_array_fetch(&server_value, _SERVER, name, PH_NOISY);
RETURN_CCTOR(server_value);
}
RETURN_MM_NULL();
}
/**
* Checks whether the behavior must take action on certain event
*
* @param string $eventName
*/
PHP_METHOD(Phalcon_Mvc_Model_Behavior, mustTakeAction){
zval *event_name, *options;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &event_name);
PHALCON_OBS_VAR(options);
phalcon_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC);
if (phalcon_array_isset(options, event_name)) {
RETURN_MM_TRUE;
}
RETURN_MM_FALSE;
}
/**
* Checks if a form is registered in the forms manager
*
* @param string $name
* @return boolean
*/
PHP_METHOD(Phalcon_Forms_Manager, has){
zval *name, *forms;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &name);
PHALCON_OBS_VAR(forms);
phalcon_read_property_this(&forms, this_ptr, SL("_forms"), PH_NOISY_CC);
if (!phalcon_array_isset(forms, name)) {
RETURN_MM_TRUE;
}
RETURN_MM_FALSE;
}
/**
* Checks whether $_SERVER superglobal has certain index
*
* @param string $name
* @return mixed
*/
PHP_METHOD(Phalcon_Http_Request, hasServer){
zval *name, *_SERVER;
zval *r0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &name) == FAILURE) {
RETURN_MM_NULL();
}
phalcon_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC);
PHALCON_INIT_VAR(r0);
ZVAL_BOOL(r0, phalcon_array_isset(_SERVER, name));
RETURN_NCTOR(r0);
}
/**
* Checks if the attribute is numerical
*
*<code>
* var_dump($metaData->isNumeric(new Robots(), 'id'));
*</code>
*
* @param Phalcon\Mvc\ModelInterface $model
* @param string $attribute
* @return int
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, isNumeric){
zval *model, *attribute, *data = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &model, &attribute);
PHALCON_CALL_METHOD(&data, this_ptr, "getdatatypesnumeric", model);
if (phalcon_array_isset(data, attribute)) {
RETURN_MM_TRUE;
}
RETURN_MM_FALSE;
}
/**
* Check whether a option has been defined in the validator options
*
* @param string $option
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator, isSetOption){
zval *option, *options, *is_set = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &option);
PHALCON_OBS_VAR(options);
phalcon_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC);
PHALCON_INIT_VAR(r0);
ZVAL_BOOL(r0, phalcon_array_isset(options, option));
PHALCON_CPY_WRT(is_set, r0);
RETURN_NCTOR(is_set);
}