/** * 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); }