/**
* Returns a local path
*
* @param array|string $params
* @return string
*/
PHP_METHOD(Phalcon_Mvc_View_Engine, path){
zval *params = NULL, *dependency_injector = NULL, *url = NULL;
zval *c0 = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", ¶ms) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!params) {
PHALCON_ALLOC_ZVAL_MM(params);
ZVAL_STRING(params, "", 1);
}
PHALCON_INIT_VAR(dependency_injector);
phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_view_exception_ce, "A dependency injector container is required to obtain the 'url' service");
return;
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "url", 1);
PHALCON_INIT_VAR(url);
PHALCON_CALL_METHOD_PARAMS_1(url, dependency_injector, "getshared", c0, PH_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD_PARAMS_1(r0, url, "getpath", params, PH_NO_CHECK);
RETURN_CTOR(r0);
}
/**
* Check that the options are valid
*
*/
PHP_METHOD(Phalcon_Model_Validator_Exclusionin, checkOptions) {
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
zval *c0 = NULL, *c1 = NULL;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "domain", 1);
PHALCON_CALL_METHOD_PARAMS_1(r0, this_ptr, "issetoption", c0, PHALCON_NO_CHECK);
if (!zend_is_true(r0)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_model_exception_ce, "The option 'domain' is required for this validator");
return;
}
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "domain", 1);
PHALCON_CALL_METHOD_PARAMS_1(r2, this_ptr, "getoption", c1, PHALCON_NO_CHECK);
PHALCON_CALL_FUNC_PARAMS_1(r1, "is_array", r2, 0x03D);
if (!zend_is_true(r1)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_model_exception_ce, "Option 'domain' must be an array");
return;
}
PHALCON_MM_RESTORE();
}
/**
* Check if a model has certain attribute
*
*<code>
* var_dump($metaData->hasAttribute(new Robots(), 'name'));
*</code>
*
* @param Phalcon\Mvc\ModelInterface $model
* @param string $attribute
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, hasAttribute){
zval *model, *attribute, *column_map, *meta_data;
zval *data_types;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &model, &attribute) == FAILURE) {
RETURN_MM_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);
if (Z_TYPE_P(column_map) == IS_ARRAY) {
if (phalcon_array_isset(column_map, attribute)) {
RETURN_MM_TRUE;
}
} else {
PHALCON_INIT_VAR(meta_data);
PHALCON_CALL_METHOD_PARAMS_1(meta_data, this_ptr, "readmetadata", model);
PHALCON_OBS_VAR(data_types);
phalcon_array_fetch_long(&data_types, meta_data, 4, PH_NOISY_CC);
if (phalcon_array_isset(data_types, attribute)) {
RETURN_MM_TRUE;
}
}
RETURN_MM_FALSE;
}
/**
* Returns the messages stored in session
*
* @param boolean $remove
* @return array
*/
PHP_METHOD(Phalcon_Flash_Session, _getSessionMessages){
zval *remove, *dependency_injector, *service;
zval *session, *index_name, *messages;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &remove);
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_flash_exception_ce, "A dependency injection container is required to access the 'session' service");
return;
}
PHALCON_INIT_VAR(service);
ZVAL_STRING(service, "session", 1);
PHALCON_INIT_VAR(session);
PHALCON_CALL_METHOD_PARAMS_1(session, dependency_injector, "getshared", service);
PHALCON_INIT_VAR(index_name);
ZVAL_STRING(index_name, "_flashMessages", 1);
PHALCON_INIT_VAR(messages);
PHALCON_CALL_METHOD_PARAMS_1(messages, session, "get", index_name);
if (PHALCON_IS_TRUE(remove)) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(session, "remove", index_name);
}
RETURN_CCTOR(messages);
}
/**
* Executes the validation
*
* @param Phalcon\Validation $validator
* @param string $attribute
* @return boolean
*/
PHP_METHOD(Phalcon_Validation_Validator_InclusionIn, validate){
zval *validator, *attribute, *value, *option = NULL, *domain;
zval *message_str = NULL, *joined_domain, *type, *message;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &validator, &attribute) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, validator, "getvalue", attribute);
/**
* A domain is an array with a list of valid values
*/
PHALCON_INIT_VAR(option);
ZVAL_STRING(option, "domain", 1);
PHALCON_INIT_VAR(domain);
PHALCON_CALL_METHOD_PARAMS_1(domain, this_ptr, "getoption", option);
if (Z_TYPE_P(domain) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "Option 'domain' must be an array");
return;
}
/**
* Check if the value is contained by the array
*/
if (!phalcon_fast_in_array(value, domain TSRMLS_CC)) {
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "message", 1);
PHALCON_INIT_VAR(message_str);
PHALCON_CALL_METHOD_PARAMS_1(message_str, this_ptr, "getoption", option);
if (!zend_is_true(message_str)) {
PHALCON_INIT_VAR(joined_domain);
phalcon_fast_join_str(joined_domain, SL(", "), domain TSRMLS_CC);
PHALCON_INIT_NVAR(message_str);
PHALCON_CONCAT_SVSV(message_str, "Value of field '", attribute, "' must be part of list: ", joined_domain);
}
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "InclusionIn", 1);
PHALCON_INIT_VAR(message);
object_init_ex(message, phalcon_validation_message_ce);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(message, "__construct", message_str, attribute, type);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(validator, "appendmessage", message);
RETURN_MM_FALSE;
}
RETURN_MM_TRUE;
}
/**
* Redirect by HTTP to another action or URL
*
*<code>
* //Using a string redirect (internal/external)
* $response->redirect("posts/index");
* $response->redirect("http://en.wikipedia.org", true);
* $response->redirect("http://www.example.com/new-location", true, 301);
*</code>
*
* @param string $location
* @param boolean $externalRedirect
* @param int $statusCode
* @return Phalcon\Http\ResponseInterface
*/
PHP_METHOD(Phalcon_Http_Response, redirect){
zval *location = NULL, *external_redirect = NULL, *status_code = NULL;
zval *header = NULL, *dependency_injector, *service;
zval *url, *status_text, *header_name;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zzz", &location, &external_redirect, &status_code) == FAILURE) {
RETURN_MM_NULL();
}
if (!location) {
PHALCON_INIT_VAR(location);
}
if (!external_redirect) {
PHALCON_INIT_VAR(external_redirect);
ZVAL_BOOL(external_redirect, 0);
}
if (!status_code) {
PHALCON_INIT_VAR(status_code);
ZVAL_LONG(status_code, 302);
}
if (zend_is_true(external_redirect)) {
PHALCON_CPY_WRT(header, location);
} else {
PHALCON_INIT_VAR(dependency_injector);
PHALCON_CALL_METHOD(dependency_injector, this_ptr, "getdi");
PHALCON_INIT_VAR(service);
ZVAL_STRING(service, "url", 1);
PHALCON_INIT_VAR(url);
PHALCON_CALL_METHOD_PARAMS_1(url, dependency_injector, "getshared", service);
PHALCON_INIT_VAR(header);
PHALCON_CALL_METHOD_PARAMS_1(header, url, "get", location);
}
/**
* The HTTP status is 302 by default, a temporary redirection
*/
PHALCON_INIT_VAR(status_text);
ZVAL_STRING(status_text, "Redirect", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "setstatuscode", status_code, status_text);
/**
* Change the current location using 'Location'
*/
PHALCON_INIT_VAR(header_name);
ZVAL_STRING(header_name, "Location", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "setheader", header_name, header);
RETURN_THIS();
}
/**
* Executes the validator
*
* @param Phalcon\Mvc\ModelInterface $record
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator_Numericality, validate){
zval *record, *option = NULL, *field, *value, *is_numeric;
zval *message = NULL, *type;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &record) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(option);
ZVAL_STRING(option, "field", 1);
PHALCON_INIT_VAR(field);
PHALCON_CALL_METHOD_PARAMS_1(field, this_ptr, "getoption", option, PH_NO_CHECK);
if (Z_TYPE_P(field) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Field name must be a string");
return;
}
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK);
/**
* Check if the value is numeric using is_numeric in the PHP userland
*/
PHALCON_INIT_VAR(is_numeric);
PHALCON_CALL_FUNC_PARAMS_1(is_numeric, "is_numeric", value);
if (!zend_is_true(is_numeric)) {
/**
* Check if the developer has defined a custom message
*/
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "message", 1);
PHALCON_INIT_VAR(message);
PHALCON_CALL_METHOD_PARAMS_1(message, this_ptr, "getoption", option, PH_NO_CHECK);
if (!zend_is_true(message)) {
PHALCON_INIT_NVAR(message);
PHALCON_CONCAT_SVS(message, "Value of field '", field, "' must be numeric");
}
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "Numericality", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", message, field, type, PH_NO_CHECK);
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
/**
* Executes validator
*
* @return boolean
*/
PHP_METHOD(Phalcon_Model_Validator_Exclusionin, validate) {
zval *domain = NULL, *field_name = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL, *c3 = NULL;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD(r0, this_ptr, "isrequired", PHALCON_NO_CHECK);
if (zend_is_true(r0)) {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "domain", 1);
PHALCON_CALL_METHOD_PARAMS_1(r1, this_ptr, "issetoption", c0, PHALCON_NO_CHECK);
if (zend_is_true(r1)) {
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "domain", 1);
PHALCON_CALL_METHOD_PARAMS_1(r2, this_ptr, "getoption", c1, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(domain, r2);
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_CALL_METHOD(r4, this_ptr, "getvalue", PHALCON_NO_CHECK);
PHALCON_CALL_FUNC_PARAMS_2(r3, "in_array", r4, domain, 0x03E);
if (zend_is_true(r3)) {
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_CALL_METHOD(r5, this_ptr, "getfieldname", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(field_name, r5);
PHALCON_ALLOC_ZVAL_MM(r6);
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, ", ", 1);
PHALCON_ALLOC_ZVAL_MM(r7);
phalcon_fast_join(r7, c2, domain TSRMLS_CC);
PHALCON_CONCAT_SVSV(r6, "Value of field '", field_name, "' must not be part of list: ", r7);
PHALCON_INIT_VAR(c3);
ZVAL_STRING(c3, "exclusion", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", r6, field_name, c3, PHALCON_NO_CHECK);
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
/**
* Executes the validator
*
* @param Phalcon\Mvc\ModelInterface $record
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator_PresenceOf, validate){
zval *record, *option = NULL, *field_name, *value, *message = NULL;
zval *type;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &record) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(option);
ZVAL_STRING(option, "field", 1);
PHALCON_INIT_VAR(field_name);
PHALCON_CALL_METHOD_PARAMS_1(field_name, this_ptr, "getoption", option, PH_NO_CHECK);
if (Z_TYPE_P(field_name) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Field name must be a string");
return;
}
/**
* A value is null when it is identical to null or a empty string
*/
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field_name, PH_NO_CHECK);
if (PHALCON_IS_EMPTY(value)) {
/**
* Check if the developer has defined a custom message
*/
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "message", 1);
PHALCON_INIT_VAR(message);
PHALCON_CALL_METHOD_PARAMS_1(message, this_ptr, "getoption", option, PH_NO_CHECK);
if (!zend_is_true(message)) {
PHALCON_INIT_NVAR(message);
PHALCON_CONCAT_SVS(message, "'", field_name, "' is required");
}
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "PresenceOf", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", message, field_name, type, PH_NO_CHECK);
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
/**
* Return a URL service from the DI
*
* @return Phalcon\Mvc\UrlInterface
*/
PHP_METHOD(Phalcon_Tag, getUrlService){
zval *url = NULL, *dependency_injector = NULL, *service;
PHALCON_MM_GROW();
PHALCON_OBSERVE_VAR(url);
phalcon_read_static_property(&url, SL("phalcon\\tag"), SL("_urlService") TSRMLS_CC);
if (Z_TYPE_P(url) == IS_NULL) {
PHALCON_OBSERVE_VAR(dependency_injector);
phalcon_read_static_property(&dependency_injector, SL("phalcon\\tag"), SL("_dependencyInjector") TSRMLS_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_INIT_NVAR(dependency_injector);
PHALCON_CALL_STATIC(dependency_injector, "phalcon\\di", "getdefault");
}
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "A dependency injector container is required to obtain the \"url\" service");
return;
}
PHALCON_INIT_VAR(service);
ZVAL_STRING(service, "url", 1);
PHALCON_INIT_NVAR(url);
PHALCON_CALL_METHOD_PARAMS_1(url, dependency_injector, "getshared", service, PH_NO_CHECK);
phalcon_update_static_property(SL("phalcon\\tag"), SL("_urlService"), url TSRMLS_CC);
}
RETURN_CCTOR(url);
}
/**
* Returns insert id for the auto_increment column inserted in the last SQL statement
*
* @param string $sequenceName
* @return int
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, lastInsertId){
zval *sequence_name = NULL, *pdo = NULL, *insert_id = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &sequence_name) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!sequence_name) {
PHALCON_ALLOC_ZVAL_MM(sequence_name);
ZVAL_NULL(sequence_name);
}
PHALCON_INIT_VAR(pdo);
phalcon_read_property(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC);
if (Z_TYPE_P(pdo) != IS_OBJECT) {
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
PHALCON_INIT_VAR(insert_id);
PHALCON_CALL_METHOD_PARAMS_1(insert_id, pdo, "lastinsertid", sequence_name, PH_NO_CHECK);
RETURN_CCTOR(insert_id);
}
/**
* Gets HTTP schema (http/https)
*
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, getScheme){
zval *https_header, *https, *scheme = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(https_header);
ZVAL_STRING(https_header, "HTTPS", 1);
PHALCON_INIT_VAR(https);
PHALCON_CALL_METHOD_PARAMS_1(https, this_ptr, "getserver", https_header);
if (zend_is_true(https)) {
if (PHALCON_IS_STRING(https, "off")) {
PHALCON_INIT_VAR(scheme);
ZVAL_STRING(scheme, "http", 1);
} else {
PHALCON_INIT_NVAR(scheme);
ZVAL_STRING(scheme, "https", 1);
}
} else {
PHALCON_INIT_NVAR(scheme);
ZVAL_STRING(scheme, "http", 1);
}
RETURN_CTOR(scheme);
}
/**
* Checks for annotations in the controller docblock
*
* @param string $handler
* @param Phalcon\Annotations\AdapterInterface
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, processControllerAnnotation){
zval *handler, *annotation, *lowercased, *name;
zval *position, *value;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &handler, &annotation) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_INIT_VAR(lowercased);
phalcon_fast_strtolower(lowercased, handler);
PHALCON_INIT_VAR(name);
PHALCON_CALL_METHOD(name, annotation, "getname");
/**
* @RoutePrefix add a prefix for all the routes defined in the model
*/
if (PHALCON_IS_STRING(name, "RoutePrefix")) {
PHALCON_INIT_VAR(position);
ZVAL_LONG(position, 0);
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, annotation, "getargument", position);
phalcon_update_property_zval(this_ptr, SL("_routePrefix"), value TSRMLS_CC);
}
PHALCON_MM_RESTORE();
}
/**
* Drops a table from a schema/database
*
* @param string $tableName
* @param string $schemaName
* @param boolean $ifExists
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, dropTable){
zval *table_name = NULL, *schema_name = NULL, *if_exists = NULL, *sql = NULL;
zval *t0 = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &table_name, &schema_name, &if_exists) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!if_exists) {
PHALCON_ALLOC_ZVAL_MM(if_exists);
ZVAL_BOOL(if_exists, 1);
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_dialect"), PH_NOISY_CC);
PHALCON_INIT_VAR(sql);
PHALCON_CALL_METHOD_PARAMS_3(sql, t0, "droptable", table_name, schema_name, if_exists, PH_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD_PARAMS_1(r0, this_ptr, "execute", sql, PH_NO_CHECK);
RETURN_CTOR(r0);
}
/**
* Returns a Dispatcher service from the DI
*
* @return Phalcon\Mvc\Dispatcher
*/
PHP_METHOD(Phalcon_Tag, getDispatcherService){
zval *dependency_injector = NULL, *dispatcher = NULL;
zval *c0 = NULL;
PHALCON_MM_GROW();
PHALCON_OBSERVE_VAR(dependency_injector);
phalcon_read_static_property(&dependency_injector, SL("phalcon\\tag"), SL("_dependencyInjector") TSRMLS_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_INIT_VAR(dependency_injector);
PHALCON_CALL_STATIC(dependency_injector, "phalcon\\di", "getdefault");
}
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "A dependency injector container is required to obtain the \"dispatcher\" service");
return;
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "dispatcher", 1);
PHALCON_INIT_VAR(dispatcher);
PHALCON_CALL_METHOD_PARAMS_1(dispatcher, dependency_injector, "getshared", c0, PH_NO_CHECK);
RETURN_CCTOR(dispatcher);
}
/**
* Returns the annotations found in all the class' methods
*
* @param string $className
* @return array
*/
PHP_METHOD(Phalcon_Annotations_Adapter, getProperties){
zval *class_name, *class_annotations, *properties = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &class_name);
/**
* Get the full annotations from the class
*/
PHALCON_INIT_VAR(class_annotations);
PHALCON_CALL_METHOD_PARAMS_1(class_annotations, this_ptr, "get", class_name);
/**
* A valid annotations reflection is an object
*/
if (Z_TYPE_P(class_annotations) == IS_OBJECT) {
PHALCON_INIT_VAR(properties);
PHALCON_CALL_METHOD(properties, class_annotations, "getpropertiesannotations");
RETURN_CCTOR(properties);
}
PHALCON_INIT_NVAR(properties);
array_init(properties);
RETURN_CCTOR(properties);
}
/**
* Adds a message to the session flasher
*
* @param string $type
* @param string $message
*/
PHP_METHOD(Phalcon_Flash_Session, message){
zval *type, *message, *remove, *messages = NULL;
zval *a0 = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &type, &message);
PHALCON_INIT_VAR(remove);
ZVAL_BOOL(remove, 0);
PHALCON_INIT_VAR(messages);
PHALCON_CALL_METHOD_PARAMS_1(messages, this_ptr, "_getsessionmessages", remove);
if (Z_TYPE_P(messages) != IS_ARRAY) {
PHALCON_INIT_NVAR(messages);
array_init(messages);
}
if (!phalcon_array_isset(messages, type)) {
PHALCON_INIT_VAR(a0);
array_init(a0);
phalcon_array_update_zval(&messages, type, &a0, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
phalcon_array_update_append_multi_2(&messages, type, message, 0 TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "_setsessionmessages", messages);
PHALCON_MM_RESTORE();
}
/**
* Renders the element widget
*
* @param array $attributes
* @return string
*/
PHP_METHOD(Phalcon_Forms_Element_Select, render){
zval *attributes = NULL, *options, *widget_attributes;
zval *code;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &attributes) == FAILURE) {
RETURN_MM_NULL();
}
if (!attributes) {
PHALCON_INIT_VAR(attributes);
}
PHALCON_OBS_VAR(options);
phalcon_read_property(&options, this_ptr, SL("_options"), PH_NOISY_CC);
PHALCON_INIT_VAR(widget_attributes);
PHALCON_CALL_METHOD_PARAMS_1(widget_attributes, this_ptr, "prepareattributes", attributes);
PHALCON_INIT_VAR(code);
PHALCON_CALL_STATIC_PARAMS_2(code, "phalcon\\tag\\select", "selectfield", widget_attributes, options);
RETURN_CCTOR(code);
}
/**
* Creates a Phalcon\Mvc\Model\Query and execute it
*
* @param string $phql
* @param array $placeholders
* @return Phalcon\Mvc\Model\Query
*/
PHP_METHOD(Phalcon_Mvc_Model_Manager, executeQuery){
zval *phql = NULL, *placeholders = NULL, *dependency_injector = NULL;
zval *query = NULL, *result = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &phql, &placeholders) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!placeholders) {
PHALCON_ALLOC_ZVAL_MM(placeholders);
ZVAL_NULL(placeholders);
}
PHALCON_INIT_VAR(dependency_injector);
phalcon_read_property(&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 injection object is required to access ORM services");
return;
}
PHALCON_INIT_VAR(query);
object_init_ex(query, phalcon_mvc_model_query_ce);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(query, "__construct", phql, PH_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(query, "setdi", dependency_injector, PH_NO_CHECK);
PHALCON_INIT_VAR(result);
PHALCON_CALL_METHOD_PARAMS_1(result, query, "execute", placeholders, PH_NO_CHECK);
RETURN_CCTOR(result);
}
/**
* Sets the DependencyInjector container
*
* @param Phalcon\DiInterface $dependencyInjector
*/
PHP_METHOD(Phalcon_Mvc_Micro, setDI){
zval *dependency_injector, *service, *exists;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &dependency_injector) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_application_exception_ce, "The dependency injector must be an object");
return;
}
PHALCON_INIT_VAR(service);
ZVAL_STRING(service, "application", 1);
PHALCON_INIT_VAR(exists);
PHALCON_CALL_METHOD_PARAMS_1(exists, dependency_injector, "has", service, PH_NO_CHECK);
if (!zend_is_true(exists)) {
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(dependency_injector, "set", service, this_ptr, PH_NO_CHECK);
}
phalcon_update_property_zval(this_ptr, SL("_dependencyInjector"), dependency_injector TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Renders an specific item in the form
*
* @param string $name
* @param array $attributes
* @return string
*/
PHP_METHOD(Phalcon_Forms_Form, render){
zval *name, *attributes = NULL, *elements, *exception_message;
zval *element, *code;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &name, &attributes) == FAILURE) {
RETURN_MM_NULL();
}
if (!attributes) {
PHALCON_INIT_VAR(attributes);
}
PHALCON_OBS_VAR(elements);
phalcon_read_property(&elements, this_ptr, SL("_elements"), PH_NOISY_CC);
if (!phalcon_array_isset(elements, name)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Element with ID=", name, " is not part of the form");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_forms_exception_ce, exception_message);
return;
}
PHALCON_OBS_VAR(element);
phalcon_array_fetch(&element, elements, name, PH_NOISY_CC);
PHALCON_INIT_VAR(code);
PHALCON_CALL_METHOD_PARAMS_1(code, element, "render", attributes);
RETURN_CCTOR(code);
}
/**
* Escape javascript strings by replacing non-alphanumeric chars by their hexadecimal escaped representation
*
* @param string $js
* @return string
*/
PHP_METHOD(Phalcon_Escaper, escapeJs){
zval *js, *normalized, *sanitized;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &js) == FAILURE) {
RETURN_MM_NULL();
}
if (Z_TYPE_P(js) == IS_STRING) {
if (zend_is_true(js)) {
/**
* Normalize encoding to UTF-32
*/
PHALCON_INIT_VAR(normalized);
PHALCON_CALL_METHOD_PARAMS_1(normalized, this_ptr, "normalizeencoding", js);
/**
* Escape the string
*/
PHALCON_INIT_VAR(sanitized);
phalcon_escape_js(sanitized, normalized);
RETURN_CTOR(sanitized);
}
}
RETURN_MM_NULL();
}
/**
* Maps a route to a handler that only matches if the HTTP method is HEAD
*
* @param string $routePattern
* @param callable $handler
*/
PHP_METHOD(Phalcon_Mvc_Micro, head){
zval *route_pattern, *handler, *router, *route;
zval *route_id;
zval *t0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &route_pattern, &handler) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(router);
PHALCON_CALL_METHOD(router, this_ptr, "getrouter", PH_NO_CHECK);
PHALCON_INIT_VAR(route);
PHALCON_CALL_METHOD_PARAMS_1(route, router, "addhead", route_pattern, PH_NO_CHECK);
PHALCON_INIT_VAR(route_id);
PHALCON_CALL_METHOD(route_id, route, "getrouteid", PH_NO_CHECK);
PHALCON_INIT_VAR(t0);
phalcon_read_property(&t0, this_ptr, SL("_handlers"), PH_NOISY_CC);
phalcon_array_update_zval(&t0, route_id, &handler, PH_COPY TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_handlers"), t0 TSRMLS_CC);
RETURN_CCTOR(route);
}
/**
* Returns an Escaper service from the default DI
*
* @return Phalcon\EscaperInterface
*/
PHP_METHOD(Phalcon_Tag, getEscaperService){
zval *escaper = NULL, *dependency_injector = NULL, *service;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(escaper);
phalcon_read_static_property(&escaper, SL("phalcon\\tag"), SL("_escaperService") TSRMLS_CC);
if (Z_TYPE_P(escaper) != IS_OBJECT) {
PHALCON_OBS_VAR(dependency_injector);
phalcon_read_static_property(&dependency_injector, SL("phalcon\\tag"), SL("_dependencyInjector") TSRMLS_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_INIT_NVAR(dependency_injector);
PHALCON_CALL_STATIC(dependency_injector, "phalcon\\di", "getdefault");
}
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "A dependency injector container is required to obtain the \"dispatcher\" service");
return;
}
PHALCON_INIT_VAR(service);
ZVAL_STRING(service, "escaper", 1);
PHALCON_INIT_NVAR(escaper);
PHALCON_CALL_METHOD_PARAMS_1(escaper, dependency_injector, "getshared", service);
phalcon_update_static_property(SL("phalcon\\tag"), SL("_escaperService"), escaper TSRMLS_CC);
}
RETURN_CCTOR(escaper);
}
/**
* Utility to normalize a string's encoding to UTF-32.
*
* @param string $str
* @return string
*/
PHP_METHOD(Phalcon_Escaper, normalizeEncoding){
zval *str, *encoding, *charset, *encoded;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &str) == FAILURE) {
RETURN_MM_NULL();
}
/**
* mbstring is required here
*/
if (phalcon_function_exists_ex(SS("mb_convert_encoding") TSRMLS_CC) == FAILURE) {
PHALCON_THROW_EXCEPTION_STR(phalcon_escaper_exception_ce, "Extension 'mbstring' is required");
return;
}
PHALCON_INIT_VAR(encoding);
PHALCON_CALL_METHOD_PARAMS_1(encoding, this_ptr, "detectencoding", str);
PHALCON_INIT_VAR(charset);
ZVAL_STRING(charset, "UTF-32", 1);
/**
* Convert to UTF-32 (4 byte characters, regardless of actual number of bytes in
* the character).
*/
PHALCON_INIT_VAR(encoded);
PHALCON_CALL_FUNC_PARAMS_3(encoded, "mb_convert_encoding", str, charset, encoding);
RETURN_CCTOR(encoded);
}
/**
* Returns the first row in a SQL query result
*
* @param string $sqlQuery
* @param int $fetchMode
* @return array
*/
PHP_METHOD(Phalcon_Db, fetchOne){
zval *sql_query = NULL, *fetch_mode = NULL, *result = NULL, *row = NULL, *empty_row = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &sql_query, &fetch_mode) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!fetch_mode) {
PHALCON_ALLOC_ZVAL_MM(fetch_mode);
ZVAL_LONG(fetch_mode, 2);
}
PHALCON_INIT_VAR(result);
PHALCON_CALL_METHOD_PARAMS_1(result, this_ptr, "query", sql_query, PH_NO_CHECK);
if (Z_TYPE_P(result) == IS_OBJECT) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(result, "setfetchmode", fetch_mode, PH_NO_CHECK);
PHALCON_INIT_VAR(row);
PHALCON_CALL_METHOD(row, result, "fetcharray", PH_NO_CHECK);
RETURN_CCTOR(row);
}
PHALCON_INIT_VAR(empty_row);
array_init(empty_row);
RETURN_CTOR(empty_row);
}
/**
* Drops a table from a schema/database
*
* @param string $tableName
* @param string $schemaName
* @param boolean $ifExists
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Mysql, dropTable){
zval *table_name = NULL, *schema_name = NULL, *if_exists = NULL, *sql = NULL;
zval *r0 = NULL, *r1 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &table_name, &schema_name, &if_exists) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!if_exists) {
PHALCON_INIT_VAR(if_exists);
ZVAL_BOOL(if_exists, 1);
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_STATIC_PARAMS_3(r0, "phalcon_db_dialect_mysql", "droptable", table_name, schema_name, if_exists);
PHALCON_CPY_WRT(sql, r0);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_METHOD_PARAMS_1(r1, this_ptr, "query", sql, PHALCON_NO_CHECK);
RETURN_DZVAL(r1);
}
/**
* Adds a message to the session flasher
*
* @param string $type
* @param string $message
*/
PHP_METHOD(Phalcon_Flash_Session, message){
zval *type, *message, *remove, *messages = NULL;
zval *a0 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &type, &message) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(remove);
ZVAL_BOOL(remove, 0);
PHALCON_INIT_VAR(messages);
PHALCON_CALL_METHOD_PARAMS_1(messages, this_ptr, "_getsessionmessages", remove, PH_NO_CHECK);
if (Z_TYPE_P(messages) != IS_ARRAY) {
PHALCON_INIT_NVAR(messages);
array_init(messages);
}
eval_int = phalcon_array_isset(messages, type);
if (!eval_int) {
PHALCON_INIT_VAR(a0);
array_init(a0);
phalcon_array_update_zval(&messages, type, &a0, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
phalcon_array_update_append_multi_2(&messages, type, message, 0 TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "_setsessionmessages", messages, PH_NO_CHECK);
PHALCON_MM_RESTORE();
}
/**
* Sets a Expires header to use HTTP cache
*
*<code>
* $this->response->setExpires(new DateTime());
*</code>
*
* @param DateTime $datetime
* @return Phalcon\Http\ResponseInterface
*/
PHP_METHOD(Phalcon_Http_Response, setExpires){
zval *datetime, *headers, *date, *utc_zone, *timezone;
zval *format, *utc_format, *utc_date, *expires_header;
zend_class_entry *ce0;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &datetime);
if (Z_TYPE_P(datetime) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_http_response_exception_ce, "datetime parameter must be an instance of DateTime");
return;
}
PHALCON_INIT_VAR(headers);
PHALCON_CALL_METHOD(headers, this_ptr, "getheaders");
PHALCON_INIT_VAR(date);
if (phalcon_clone(date, datetime TSRMLS_CC) == FAILURE) {
return;
}
/**
* All the expiration times are sent in UTC
*/
PHALCON_INIT_VAR(utc_zone);
ZVAL_STRING(utc_zone, "UTC", 1);
ce0 = zend_fetch_class(SL("DateTimeZone"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_INIT_VAR(timezone);
object_init_ex(timezone, ce0);
if (phalcon_has_constructor(timezone TSRMLS_CC)) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(timezone, "__construct", utc_zone);
}
/**
* Change the timezone to utc
*/
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(date, "settimezone", timezone);
PHALCON_INIT_VAR(format);
ZVAL_STRING(format, "D, d M Y H:i:s", 1);
PHALCON_INIT_VAR(utc_format);
PHALCON_CALL_METHOD_PARAMS_1(utc_format, date, "format", format);
PHALCON_INIT_VAR(utc_date);
PHALCON_CONCAT_VS(utc_date, utc_format, " GMT");
/**
* The 'Expires' header set this info
*/
PHALCON_INIT_VAR(expires_header);
ZVAL_STRING(expires_header, "Expires", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "setheader", expires_header, utc_date);
RETURN_THIS();
}
/**
* 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 = NULL, *frontend;
zval *prefix, *prefixed_key, *cached_content;
zval *content;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &key_name, &lifetime) == FAILURE) {
RETURN_MM_NULL();
}
if (!lifetime) {
PHALCON_INIT_VAR(lifetime);
}
PHALCON_OBS_VAR(memcache);
phalcon_read_property(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC);
if (Z_TYPE_P(memcache) != IS_OBJECT) {
PHALCON_CALL_METHOD_NORETURN(this_ptr, "_connect");
PHALCON_OBS_NVAR(memcache);
phalcon_read_property(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC);
}
PHALCON_OBS_VAR(frontend);
phalcon_read_property(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
PHALCON_OBS_VAR(prefix);
phalcon_read_property(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC);
PHALCON_INIT_VAR(prefixed_key);
PHALCON_CONCAT_VV(prefixed_key, prefix, key_name);
phalcon_update_property_zval(this_ptr, SL("_lastKey"), prefixed_key TSRMLS_CC);
PHALCON_INIT_VAR(cached_content);
PHALCON_CALL_METHOD_PARAMS_1(cached_content, memcache, "get", prefixed_key);
if (PHALCON_IS_FALSE(cached_content)) {
RETURN_MM_NULL();
}
PHALCON_INIT_VAR(content);
PHALCON_CALL_METHOD_PARAMS_1(content, frontend, "afterretrieve", cached_content);
RETURN_CCTOR(content);
}
