/** * Returns headers set by the user * * @return Phalcon\Http\Response\HeadersInterface */ PHP_METHOD(Phalcon_Http_Response, getHeaders){ zval *headers = NULL; PHALCON_MM_GROW(); PHALCON_OBS_VAR(headers); phalcon_read_property(&headers, this_ptr, SL("_headers"), PH_NOISY_CC); if (Z_TYPE_P(headers) == IS_NULL) { /** * A Phalcon\Http\Response\Headers bag is temporary used to manage the headers * before sent them to the client */ PHALCON_INIT_NVAR(headers); object_init_ex(headers, phalcon_http_response_headers_ce); PHALCON_CALL_METHOD_NORETURN(headers, "__construct"); phalcon_update_property_zval(this_ptr, SL("_headers"), headers TSRMLS_CC); } RETURN_CCTOR(headers); }
/** * Returns the CSS collection of assets * * @return Phalcon\Assets\Collection */ PHP_METHOD(Phalcon_Assets_Manager, getJs){ zval *collections, *collection = NULL; PHALCON_MM_GROW(); PHALCON_OBS_VAR(collections); phalcon_read_property_this(&collections, this_ptr, SL("_collections"), PH_NOISY_CC); /** * Check if the collection does not exist and create an implicit collection */ if (!phalcon_array_isset_string(collections, SS("js"))) { PHALCON_INIT_VAR(collection); object_init_ex(collection, phalcon_assets_collection_ce); RETURN_CTOR(collection); } PHALCON_OBS_NVAR(collection); phalcon_array_fetch_string(&collection, collections, SL("js"), PH_NOISY_CC); RETURN_CCTOR(collection); }
/** * Returns the cache instance used to cache * * @return Phalcon\Cache\BackendInterface */ PHP_METHOD(Phalcon_Mvc_View, getCache){ zval *cache = NULL; PHALCON_MM_GROW(); PHALCON_OBS_VAR(cache); phalcon_read_property_this(&cache, this_ptr, SL("_cache"), PH_NOISY_CC); if (zend_is_true(cache)) { if (Z_TYPE_P(cache) != IS_OBJECT) { PHALCON_INIT_NVAR(cache); PHALCON_CALL_METHOD(cache, this_ptr, "_createcache"); phalcon_update_property_this(this_ptr, SL("_cache"), cache TSRMLS_CC); } } else { PHALCON_INIT_NVAR(cache); PHALCON_CALL_METHOD(cache, this_ptr, "_createcache"); phalcon_update_property_this(this_ptr, SL("_cache"), cache TSRMLS_CC); } RETURN_CCTOR(cache); }
/** * Appends a condition to the current conditions using a OR operator * *<code> * $builder->orWhere('name = :name: AND id > :id:'); *</code> * * @param string $conditions * @return Phalcon\Mvc\Model\Query\Builder */ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, orWhere){ zval *conditions, *current_conditions, *new_conditions = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &conditions) == FAILURE) { RETURN_MM_NULL(); } PHALCON_OBS_VAR(current_conditions); phalcon_read_property(¤t_conditions, this_ptr, SL("_conditions"), PH_NOISY_CC); if (zend_is_true(current_conditions)) { PHALCON_INIT_VAR(new_conditions); PHALCON_CONCAT_SVSVS(new_conditions, "(", current_conditions, ") OR (", conditions, ")"); } else { PHALCON_CPY_WRT(new_conditions, current_conditions); } phalcon_update_property_zval(this_ptr, SL("_conditions"), new_conditions TSRMLS_CC); RETURN_THIS(); }
/** * Returns the messages that belongs to the element * The element needs to be attached to a form * * @return Phalcon\Validation\Message\Group */ PHP_METHOD(Phalcon_Forms_Element, getMessages){ zval *messages = NULL; PHALCON_MM_GROW(); /** * Get the related form */ PHALCON_OBS_VAR(messages); phalcon_read_property_this(&messages, this_ptr, SL("_messages"), PH_NOISY_CC); if (Z_TYPE_P(messages) == IS_OBJECT) { RETURN_CCTOR(messages); } PHALCON_INIT_NVAR(messages); object_init_ex(messages, phalcon_validation_message_group_ce); phalcon_call_method_noret(messages, "__construct"); phalcon_update_property_this(this_ptr, SL("_messages"), messages TSRMLS_CC); RETURN_CCTOR(messages); }
/** * Checks whether request has been made using SOAP * * @return boolean */ PHP_METHOD(Phalcon_Http_Request, isSoapRequested){ zval *server = NULL, *_SERVER, *content_type; PHALCON_MM_GROW(); phalcon_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC); PHALCON_CPY_WRT(server, _SERVER); if (phalcon_array_isset_string(server, SS("HTTP_SOAPACTION"))) { RETURN_MM_TRUE; } else { if (phalcon_array_isset_string(server, SS("CONTENT_TYPE"))) { PHALCON_OBS_VAR(content_type); phalcon_array_fetch_string(&content_type, server, SL("CONTENT_TYPE"), PH_NOISY_CC); if (phalcon_memnstr_str(content_type, SL("application/soap+xml") TSRMLS_CC)) { RETURN_MM_TRUE; } } } RETURN_MM_FALSE; }
/** * Phalcon\Cache\Backend\File constructor * * @param Phalcon\Cache\FrontendInterface $frontend * @param array $options */ PHP_METHOD(Phalcon_Cache_Backend_File, __construct){ zval *frontend, *options = NULL, *cache_dir; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &frontend, &options); if (!options) { PHALCON_INIT_VAR(options); } if (!phalcon_array_isset_string(options, SS("cacheDir"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Cache directory must be specified with the option cacheDir"); return; } PHALCON_OBS_VAR(cache_dir); phalcon_array_fetch_string(&cache_dir, options, SL("cacheDir"), PH_NOISY); PHALCON_CALL_PARENT_PARAMS_2_NORETURN(this_ptr, "Phalcon\\Cache\\Backend\\File", "__construct", frontend, options); PHALCON_MM_RESTORE(); }
/** * Returns the internal dependency injector * * @return Phalcon\DiInterface */ PHP_METHOD(Phalcon_Http_Response, getDI){ zval *dependency_injector = NULL; PHALCON_MM_GROW(); PHALCON_OBS_VAR(dependency_injector); phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_INIT_NVAR(dependency_injector); PHALCON_CALL_STATIC(dependency_injector, "phalcon\\di", "getdefault"); if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_http_request_exception_ce, "A dependency injection object is required to access the 'url' service"); return; } phalcon_update_property_zval(this_ptr, SL("_dependencyInjector"), dependency_injector TSRMLS_CC); } RETURN_CCTOR(dependency_injector); }
/** * Check whether the DI contains a service by a name * * @param string $name * @return boolean */ PHP_METHOD(Phalcon_DI, has){ zval *name, *services, *is_set_service = NULL; zval *r0 = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &name); if (Z_TYPE_P(name) != IS_STRING) { PHALCON_THROW_EXCEPTION_STR(phalcon_di_exception_ce, "The service alias must be a string"); return; } PHALCON_OBS_VAR(services); phalcon_read_property_this(&services, this_ptr, SL("_services"), PH_NOISY_CC); PHALCON_INIT_VAR(r0); ZVAL_BOOL(r0, phalcon_array_isset(services, name)); PHALCON_CPY_WRT(is_set_service, r0); RETURN_NCTOR(is_set_service); }
/** * Add a model to take part of the query * *<code> * $builder->addFrom('Robots', 'r'); *</code> * * @param string $model * @param string $alias * @return Phalcon\Mvc\Model\Query\Builder */ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, addFrom){ zval *model, *alias = NULL, *models = NULL, *current_model = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &model, &alias); if (!alias) { PHALCON_INIT_VAR(alias); } PHALCON_OBS_VAR(models); phalcon_read_property_this(&models, this_ptr, SL("_models"), PH_NOISY_CC); if (Z_TYPE_P(models) != IS_ARRAY) { if (Z_TYPE_P(models) != IS_NULL) { PHALCON_CPY_WRT(current_model, models); PHALCON_INIT_NVAR(models); array_init(models); phalcon_array_append(&models, current_model, PH_SEPARATE); } else { PHALCON_INIT_NVAR(models); array_init(models); } } if (Z_TYPE_P(alias) == IS_STRING) { phalcon_array_update_zval(&models, alias, &model, PH_COPY | PH_SEPARATE); } else { phalcon_array_append(&models, model, PH_SEPARATE); } phalcon_update_property_this(this_ptr, SL("_models"), models TSRMLS_CC); RETURN_THIS(); }
/** * 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 *empty_arr; 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); } PHALCON_INIT_VAR(messages); PHALCON_CALL_METHOD_PARAMS_1(messages, this_ptr, "_getsessionmessages", remove); if (Z_TYPE_P(messages) == IS_ARRAY) { if (Z_TYPE_P(type) == IS_STRING) { if (phalcon_array_isset(messages, type)) { PHALCON_OBS_VAR(return_messages); phalcon_array_fetch(&return_messages, messages, type, PH_NOISY_CC); RETURN_CCTOR(return_messages); } } RETURN_CCTOR(messages); } PHALCON_INIT_VAR(empty_arr); array_init(empty_arr); RETURN_CTOR(empty_arr); }
/** * Throws an internal exception * * @param string $message * @param int $exceptionCode */ PHP_METHOD(Phalcon_CLI_Dispatcher, _throwDispatchException){ zval *message, *exception_code = NULL, *exception, *events_manager; zval *event_name, *status; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &message, &exception_code) == FAILURE) { RETURN_MM_NULL(); } if (!exception_code) { PHALCON_INIT_VAR(exception_code); ZVAL_LONG(exception_code, 0); } PHALCON_INIT_VAR(exception); object_init_ex(exception, phalcon_cli_dispatcher_exception_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(exception, "__construct", message, exception_code); PHALCON_OBS_VAR(events_manager); phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_VAR(event_name); ZVAL_STRING(event_name, "dispatch:beforeException", 1); PHALCON_INIT_VAR(status); PHALCON_CALL_METHOD_PARAMS_3(status, events_manager, "fire", event_name, this_ptr, exception); if (PHALCON_IS_FALSE(status)) { RETURN_MM_FALSE; } } phalcon_throw_exception(exception TSRMLS_CC); return; }
/** * Starts every backend * * @param int|string $keyName * @param long $lifetime * @return mixed */ PHP_METHOD(Phalcon_Cache_Multiple, start){ zval *key_name, *lifetime = NULL, *backends, *backend = NULL; HashTable *ah0; HashPosition hp0; zval **hd; 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(backends); phalcon_read_property(&backends, this_ptr, SL("_backends"), PH_NOISY_CC); if (!phalcon_is_iterable(backends, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(backend); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(backend, "start", key_name, lifetime); zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_MM_RESTORE(); }
/** * Returns the insert id for the auto_increment/serial column inserted in the lastest executed SQL statement * *<code> * //Inserting a new robot * $success = $connection->insert( * "robots", * array("Astro Boy", 1952), * array("name", "year") * ); * * //Getting the generated id * $id = $connection->lastInsertId(); *</code> * * @param string $sequenceName * @return int */ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Oracle, lastInsertId) { zval *sequence_name = NULL, *sql, *fetch_num, *ret = NULL, *insert_id; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, &sequence_name); if (!sequence_name) { sequence_name = PHALCON_GLOBAL(z_null); } PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVS(sql, "SELECT ", sequence_name, ".CURRVAL FROM dual"); PHALCON_INIT_VAR(fetch_num); ZVAL_LONG(fetch_num, PDO_FETCH_NUM); PHALCON_CALL_METHOD(&ret, this_ptr, "fetchall", sql, fetch_num); PHALCON_OBS_VAR(insert_id); phalcon_array_fetch_long(&insert_id, ret, 0, PH_NOISY); RETURN_CCTOR(insert_id); }
/** * Removes all events from the EventsManager * * @param string $type */ PHP_METHOD(Phalcon_Events_Manager, detachAll){ zval *type = NULL, *events = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, &type); if (!type) { PHALCON_INIT_VAR(type); } PHALCON_OBS_VAR(events); phalcon_read_property_this(&events, this_ptr, SL("_events"), PH_NOISY_CC); if (Z_TYPE_P(type) == IS_NULL) { PHALCON_INIT_NVAR(events); } else { phalcon_array_unset(&events, type, PH_SEPARATE); } phalcon_update_property_this(this_ptr, SL("_events"), events TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Commmits active transactions within the manager * */ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, commit){ zval *transactions, *transaction = NULL, *connection = NULL; zval *is_under_transaction = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); PHALCON_OBS_VAR(transactions); phalcon_read_property_this(&transactions, this_ptr, SL("_transactions"), PH_NOISY_CC); if (Z_TYPE_P(transactions) == IS_ARRAY) { phalcon_is_iterable(transactions, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(transaction); PHALCON_INIT_NVAR(connection); phalcon_call_method(connection, transaction, "getconnection"); PHALCON_INIT_NVAR(is_under_transaction); phalcon_call_method(is_under_transaction, connection, "isundertransaction"); if (zend_is_true(is_under_transaction)) { phalcon_call_method_noret(connection, "commit"); } zend_hash_move_forward_ex(ah0, &hp0); } } PHALCON_MM_RESTORE(); }
/** * 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(); }
/** * Reads meta-data from APC * * @param string $key * @return array */ PHP_METHOD(Phalcon_Mvc_Model_MetaData_Apc, read){ zval *key, *prefix, *apc_key, *data; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &key) == FAILURE) { RETURN_MM_NULL(); } PHALCON_OBS_VAR(prefix); phalcon_read_property_this(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC); PHALCON_INIT_VAR(apc_key); PHALCON_CONCAT_SVV(apc_key, "$PMM$", prefix, key); PHALCON_INIT_VAR(data); PHALCON_CALL_FUNC_PARAMS_1(data, "apc_fetch", apc_key); if (Z_TYPE_P(data) == IS_ARRAY) { RETURN_CCTOR(data); } RETURN_MM_NULL(); }
/** * Gets HTTP raw request body * * @return string */ PHP_METHOD(Phalcon_Http_Request, getRawBody){ zval *raw_body, *input, *contents; PHALCON_MM_GROW(); PHALCON_OBS_VAR(raw_body); phalcon_read_property_this(&raw_body, this_ptr, SL("_rawBody"), PH_NOISY_CC); if (PHALCON_IS_EMPTY(raw_body)) { PHALCON_INIT_VAR(input); ZVAL_STRING(input, "php://input", 1); PHALCON_INIT_VAR(contents); phalcon_file_get_contents(contents, input TSRMLS_CC); /** * We need store the read raw body because it can't be read again */ phalcon_update_property_this(this_ptr, SL("_rawBody"), contents TSRMLS_CC); RETURN_CCTOR(contents); } RETURN_CCTOR(raw_body); }
/** * 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(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &remove) == FAILURE) { RETURN_MM_NULL(); } PHALCON_OBS_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_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); }
/** * Sets session's options * *<code> * $session->setOptions(array( * 'uniqueId' => 'my-private-app' * )); *</code> * * @param array $options */ PHP_METHOD(Phalcon_Session_Adapter, setOptions){ zval *options, *unique_id; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &options) == FAILURE) { RETURN_MM_NULL(); } if (Z_TYPE_P(options) == IS_ARRAY) { if (phalcon_array_isset_string(options, SS("uniqueId"))) { PHALCON_OBS_VAR(unique_id); phalcon_array_fetch_string(&unique_id, options, SL("uniqueId"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_uniqueId"), unique_id TSRMLS_CC); } phalcon_update_property_zval(this_ptr, SL("_options"), options TSRMLS_CC); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_session_exception_ce, "Options must be an Array"); return; } PHALCON_MM_RESTORE(); }
/** * Renders a partial view * * <code> * //Show a partial inside another view * $this->partial('shared/footer'); * </code> * * @param string $partialPath * @return string */ PHP_METHOD(Phalcon_Mvc_View, partial){ zval *partial_path, *zfalse, *partials_dir, *real_path; zval *engines; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &partial_path); PHALCON_INIT_VAR(zfalse); ZVAL_BOOL(zfalse, 0); PHALCON_OBS_VAR(partials_dir); phalcon_read_property_this(&partials_dir, this_ptr, SL("_partialsDir"), PH_NOISY_CC); PHALCON_INIT_VAR(real_path); PHALCON_CONCAT_VV(real_path, partials_dir, partial_path); PHALCON_INIT_VAR(engines); PHALCON_CALL_METHOD(engines, this_ptr, "_loadtemplateengines"); PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, real_path, zfalse, zfalse, zfalse); PHALCON_MM_RESTORE(); }
/** * Phalcon\Annotations\Adapter\Files constructor * * @param array $options */ PHP_METHOD(Phalcon_Annotations_Adapter_Files, __construct){ zval *options = NULL, *annotations_dir; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &options) == FAILURE) { RETURN_MM_NULL(); } if (!options) { PHALCON_INIT_VAR(options); } if (Z_TYPE_P(options) == IS_ARRAY) { if (phalcon_array_isset_string(options, SS("annotationsDir"))) { PHALCON_OBS_VAR(annotations_dir); phalcon_array_fetch_string(&annotations_dir, options, SL("annotationsDir"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_annotationsDir"), annotations_dir TSRMLS_CC); } } PHALCON_MM_RESTORE(); }
/** * Sets a global formatter * * @param Phalcon\Logger\FormatterInterface $formatter */ PHP_METHOD(Phalcon_Logger_Multiple, setFormatter){ zval *formatter, *loggers, *logger = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &formatter) == FAILURE) { RETURN_MM_NULL(); } PHALCON_OBS_VAR(loggers); phalcon_read_property_this(&loggers, this_ptr, SL("_loggers"), PH_NOISY_CC); if (Z_TYPE_P(loggers) == IS_ARRAY) { if (!phalcon_is_iterable(loggers, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(logger); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(logger, "setformatter", formatter); zend_hash_move_forward_ex(ah0, &hp0); } } phalcon_update_property_this(this_ptr, SL("_formatter"), formatter TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Builds a SELECT statement * * @param array $definition * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Oracle, select){ zval *definition, *escape_char = NULL, *columns, *selected_columns, *distinct; zval *column = NULL, *column_item = NULL, *column_sql = NULL, *columns_sql = NULL; zval *column_domain = NULL, *column_domain_sql = NULL, *column_alias = NULL; zval *column_alias_sql = NULL, *tables, *selected_tables; zval *table = NULL, *sql_table = NULL, *tables_sql = NULL, *sql, *joins; zval *join = NULL, *type = NULL, *sql_join = NULL, *join_conditions_array = NULL; zval *join_expressions = NULL, *join_condition = NULL, *join_expression = NULL; zval *join_conditions = NULL, *where_conditions; zval *where_expression = NULL, *group_items, *group_fields; zval *group_field = NULL, *group_expression = NULL, *group_sql; zval *group_clause, *having_conditions, *having_expression = NULL; zval *order_fields, *order_items, *order_item = NULL; zval *order_expression = NULL, *order_sql_item = NULL, *sql_order_type = NULL; zval *order_sql_item_type = NULL, *order_sql, *limit_value; zval *number, *offset, *tmp1 = NULL, *tmp2 = NULL; zval *z_one, *ini_range, *end_range = NULL, *sql_limit; HashTable *ah0, *ah1, *ah2, *ah3, *ah4, *ah5; HashPosition hp0, hp1, hp2, hp3, hp4, hp5; zval **hd; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &definition) == FAILURE) { RETURN_NULL(); } if (Z_TYPE_P(definition) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STRW(phalcon_db_exception_ce, "Invalid SELECT definition"); return; } if (!phalcon_array_isset_string(definition, SS("tables"))) { PHALCON_THROW_EXCEPTION_STRW(phalcon_db_exception_ce, "The index 'tables' is required in the definition array"); return; } if (!phalcon_array_isset_string(definition, SS("columns"))) { PHALCON_THROW_EXCEPTION_STRW(phalcon_db_exception_ce, "The index 'columns' is required in the definition array"); return; } PHALCON_MM_GROW(); if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_OBS_VAR(escape_char); phalcon_read_property_this(&escape_char, this_ptr, SL("_escapeChar"), PH_NOISY TSRMLS_CC); } else { PHALCON_INIT_NVAR(escape_char); } PHALCON_OBS_VAR(columns); phalcon_array_fetch_string(&columns, definition, SL("columns"), PH_NOISY); if (Z_TYPE_P(columns) == IS_ARRAY) { PHALCON_INIT_VAR(selected_columns); array_init(selected_columns); phalcon_is_iterable(columns, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(column); /** * Escape column name */ PHALCON_OBS_NVAR(column_item); phalcon_array_fetch_long(&column_item, column, 0, PH_NOISY); if (Z_TYPE_P(column_item) == IS_ARRAY) { PHALCON_CALL_METHOD(&column_sql, this_ptr, "getsqlexpression", column_item, escape_char); } else if (PHALCON_IS_STRING(column_item, "*")) { PHALCON_CPY_WRT(column_sql, column_item); } else if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_NVAR(column_sql); PHALCON_CONCAT_VVV(column_sql, escape_char, column_item, escape_char); } else { PHALCON_CPY_WRT(columns_sql, column_item); } /** * Escape column domain */ if (phalcon_array_isset_long(column, 1)) { PHALCON_OBS_NVAR(column_domain); phalcon_array_fetch_long(&column_domain, column, 1, PH_NOISY); if (zend_is_true(column_domain)) { if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_NVAR(column_domain_sql); PHALCON_CONCAT_VVVSV(column_domain_sql, escape_char, column_domain, escape_char, ".", column_sql); } else { PHALCON_INIT_NVAR(column_domain_sql); PHALCON_CONCAT_VSV(column_domain_sql, column_domain, ".", column_sql); } } else { PHALCON_CPY_WRT(column_domain_sql, column_sql); } } else { PHALCON_CPY_WRT(column_domain_sql, column_sql); } /** * Escape column alias */ if (phalcon_array_isset_long(column, 2)) { PHALCON_OBS_NVAR(column_alias); phalcon_array_fetch_long(&column_alias, column, 2, PH_NOISY); if (zend_is_true(column_alias)) { if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_NVAR(column_alias_sql); PHALCON_CONCAT_VSVVV(column_alias_sql, column_domain_sql, " ", escape_char, column_alias, escape_char); } else { PHALCON_INIT_NVAR(column_alias_sql); PHALCON_CONCAT_VSV(column_alias_sql, column_domain_sql, " ", column_alias); } } else { PHALCON_CPY_WRT(column_alias_sql, column_domain_sql); } } else { PHALCON_CPY_WRT(column_alias_sql, column_domain_sql); } phalcon_array_append(&selected_columns, column_alias_sql, PH_SEPARATE); zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_INIT_VAR(columns_sql); phalcon_fast_join_str(columns_sql, SL(", "), selected_columns TSRMLS_CC); } else { PHALCON_CPY_WRT(columns_sql, columns); } /** * Check and escape tables */ PHALCON_OBS_VAR(tables); phalcon_array_fetch_string(&tables, definition, SL("tables"), PH_NOISY); if (Z_TYPE_P(tables) == IS_ARRAY) { PHALCON_INIT_VAR(selected_tables); array_init(selected_tables); phalcon_is_iterable(tables, &ah1, &hp1, 0, 0); while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_HVALUE(table); PHALCON_CALL_METHOD(&sql_table, this_ptr, "getsqltable", table, escape_char); phalcon_array_append(&selected_tables, sql_table, PH_SEPARATE); zend_hash_move_forward_ex(ah1, &hp1); } PHALCON_INIT_VAR(tables_sql); phalcon_fast_join_str(tables_sql, SL(", "), selected_tables TSRMLS_CC); } else { PHALCON_CPY_WRT(tables_sql, tables); } PHALCON_INIT_VAR(sql); if (phalcon_array_isset_string_fetch(&distinct, definition, SS("definition"))) { assert(Z_TYPE_P(distinct) == IS_LONG); if (Z_LVAL_P(distinct) == 0) { ZVAL_STRING(sql, "SELECT ALL ", 1); } else if (Z_LVAL_P(distinct) == 1) { ZVAL_STRING(sql, "SELECT DISTINCT ", 1); } else { ZVAL_STRING(sql, "SELECT ", 1); } } else { ZVAL_STRING(sql, "SELECT ", 1); } /** * Check for joins */ if (phalcon_array_isset_string(definition, SS("joins"))) { PHALCON_OBS_VAR(joins); phalcon_array_fetch_string(&joins, definition, SL("joins"), PH_NOISY); phalcon_is_iterable(joins, &ah2, &hp2, 0, 0); while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) { PHALCON_GET_HVALUE(join); PHALCON_OBS_NVAR(type); phalcon_array_fetch_string(&type, join, SL("type"), PH_NOISY); PHALCON_OBS_NVAR(table); phalcon_array_fetch_string(&table, join, SL("source"), PH_NOISY); PHALCON_CALL_METHOD(&sql_table, this_ptr, "getsqltable", table, escape_char); phalcon_array_append(&selected_tables, sql_table, PH_SEPARATE); PHALCON_INIT_NVAR(sql_join); PHALCON_CONCAT_SVSV(sql_join, " ", type, " JOIN ", sql_table); /** * Check if the join has conditions */ if (phalcon_array_isset_string(join, SS("conditions"))) { PHALCON_OBS_NVAR(join_conditions_array); phalcon_array_fetch_string(&join_conditions_array, join, SL("conditions"), PH_NOISY); if (phalcon_fast_count_ev(join_conditions_array TSRMLS_CC)) { PHALCON_INIT_NVAR(join_expressions); array_init(join_expressions); phalcon_is_iterable(join_conditions_array, &ah3, &hp3, 0, 0); while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) { PHALCON_GET_HVALUE(join_condition); PHALCON_CALL_METHOD(&join_expression, this_ptr, "getsqlexpression", join_condition, escape_char); phalcon_array_append(&join_expressions, join_expression, PH_SEPARATE); zend_hash_move_forward_ex(ah3, &hp3); } PHALCON_INIT_NVAR(join_conditions); phalcon_fast_join_str(join_conditions, SL(" AND "), join_expressions TSRMLS_CC); PHALCON_SCONCAT_SV(sql_join, " ON ", join_conditions); } } phalcon_concat_self(&sql, sql_join TSRMLS_CC); zend_hash_move_forward_ex(ah2, &hp2); } } /** * Check for a WHERE clause */ if (phalcon_array_isset_string(definition, SS("where"))) { PHALCON_OBS_VAR(where_conditions); phalcon_array_fetch_string(&where_conditions, definition, SL("where"), PH_NOISY); if (Z_TYPE_P(where_conditions) == IS_ARRAY) { PHALCON_CALL_METHOD(&where_expression, this_ptr, "getsqlexpression", where_conditions, escape_char); PHALCON_SCONCAT_SV(sql, " WHERE ", where_expression); } else { PHALCON_SCONCAT_SV(sql, " WHERE ", where_conditions); } } /** * Check for a GROUP clause */ if (phalcon_array_isset_string(definition, SS("group"))) { PHALCON_INIT_VAR(group_items); array_init(group_items); PHALCON_OBS_VAR(group_fields); phalcon_array_fetch_string(&group_fields, definition, SL("group"), PH_NOISY); phalcon_is_iterable(group_fields, &ah4, &hp4, 0, 0); while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) { PHALCON_GET_HVALUE(group_field); PHALCON_CALL_METHOD(&group_expression, this_ptr, "getsqlexpression", group_field, escape_char); phalcon_array_append(&group_items, group_expression, PH_SEPARATE); zend_hash_move_forward_ex(ah4, &hp4); } PHALCON_INIT_VAR(group_sql); phalcon_fast_join_str(group_sql, SL(", "), group_items TSRMLS_CC); PHALCON_INIT_VAR(group_clause); PHALCON_CONCAT_SV(group_clause, " GROUP BY ", group_sql); phalcon_concat_self(&sql, group_clause TSRMLS_CC); } /** * Check for a HAVING clause */ if (phalcon_array_isset_string(definition, SS("having"))) { PHALCON_OBS_VAR(having_conditions); phalcon_array_fetch_string(&having_conditions, definition, SL("having"), PH_NOISY); PHALCON_CALL_METHOD(&having_expression, this_ptr, "getsqlexpression", having_conditions, escape_char); PHALCON_SCONCAT_SV(sql, " HAVING ", having_expression); } /** * Check for a ORDER clause */ if (phalcon_array_isset_string(definition, SS("order"))) { PHALCON_OBS_VAR(order_fields); phalcon_array_fetch_string(&order_fields, definition, SL("order"), PH_NOISY); PHALCON_INIT_VAR(order_items); array_init(order_items); phalcon_is_iterable(order_fields, &ah5, &hp5, 0, 0); while (zend_hash_get_current_data_ex(ah5, (void**) &hd, &hp5) == SUCCESS) { PHALCON_GET_HVALUE(order_item); PHALCON_OBS_NVAR(order_expression); phalcon_array_fetch_long(&order_expression, order_item, 0, PH_NOISY); PHALCON_CALL_METHOD(&order_sql_item, this_ptr, "getsqlexpression", order_expression, escape_char); /** * In the numeric 1 position could be a ASC/DESC clause */ if (phalcon_array_isset_long(order_item, 1)) { PHALCON_OBS_NVAR(sql_order_type); phalcon_array_fetch_long(&sql_order_type, order_item, 1, PH_NOISY); PHALCON_INIT_NVAR(order_sql_item_type); PHALCON_CONCAT_VSV(order_sql_item_type, order_sql_item, " ", sql_order_type); } else { PHALCON_CPY_WRT(order_sql_item_type, order_sql_item); } phalcon_array_append(&order_items, order_sql_item_type, PH_SEPARATE); zend_hash_move_forward_ex(ah5, &hp5); } PHALCON_INIT_VAR(order_sql); phalcon_fast_join_str(order_sql, SL(", "), order_items TSRMLS_CC); PHALCON_SCONCAT_SV(sql, " ORDER BY ", order_sql); } /** * Oracle does not implement the LIMIT clause as some RDBMS do. * We have to simulate it with subqueries and ROWNUM. * Unfortunately because we use the column wildcard "*", * this puts an extra column into the query result set. */ if (phalcon_array_isset_string_fetch(&limit_value, definition, SS("limit"))) { if (likely(Z_TYPE_P(limit_value) == IS_ARRAY)) { if (likely(phalcon_array_isset_string_fetch(&number, limit_value, SS("number")))) { PHALCON_OBS_NVAR(tmp1); phalcon_array_fetch_string(&tmp1, number, SL("value"), PH_NOISY); if (phalcon_array_isset_string_fetch(&offset, limit_value, SS("offset"))) { PHALCON_OBS_NVAR(tmp2); phalcon_array_fetch_string(&tmp2, offset, SL("value"), PH_NOISY); } else { PHALCON_INIT_NVAR(tmp2); ZVAL_LONG(tmp2, 0); } z_one = PHALCON_GLOBAL(z_one); PHALCON_INIT_VAR(ini_range); phalcon_add_function(ini_range, tmp2, z_one TSRMLS_CC); PHALCON_INIT_VAR(end_range); phalcon_add_function(end_range, tmp2, tmp1 TSRMLS_CC); PHALCON_INIT_VAR(sql_limit); PHALCON_SCONCAT_SVSVSV(sql_limit,"SELECT Z2.* FROM (SELECT Z1.*, ROWNUM DB_ROWNUM FROM ( ", sql, " ) Z1 ) Z2 WHERE Z2.DB_ROWNUM BETWEEN ", ini_range , " AND ", end_range ); PHALCON_CPY_WRT(sql, sql_limit); } } else { PHALCON_INIT_VAR(ini_range); ZVAL_LONG(ini_range, 1); PHALCON_CPY_WRT(end_range, limit_value); PHALCON_INIT_VAR(sql_limit); PHALCON_SCONCAT_SVSVSV(sql_limit,"SELECT Z2.* FROM (SELECT Z1.*, ROWNUM DB_ROWNUM FROM ( ", sql, " ) Z1 ) Z2 WHERE Z2.DB_ROWNUM BETWEEN ", ini_range , " AND ", end_range ); PHALCON_CPY_WRT(sql, sql_limit); } } RETURN_CTOR(sql); }
/** * Transform an intermediate representation for a schema/table into a database system valid expression * * @param array $table * @param string $escapeChar * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Oracle, getSqlTable){ zval *table, *escape_char = NULL, *table_name, *sql_table = NULL; zval *schema_name, *sql_schema = NULL, *alias_name; zval *sql_table_alias = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &table, &escape_char); if (!escape_char) { PHALCON_INIT_VAR(escape_char); } else { PHALCON_SEPARATE_PARAM(escape_char); } if (Z_TYPE_P(escape_char) == IS_NULL) { PHALCON_OBS_NVAR(escape_char); phalcon_read_property_this(&escape_char, this_ptr, SL("_escapeChar"), PH_NOISY TSRMLS_CC); } if (Z_TYPE_P(table) == IS_ARRAY) { /** * The index '0' is the table name */ PHALCON_OBS_VAR(table_name); phalcon_array_fetch_long(&table_name, table, 0, PH_NOISY); if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_VAR(sql_table); PHALCON_CONCAT_VVV(sql_table, escape_char, table_name, escape_char); } else { PHALCON_CPY_WRT(sql_table, table_name); } /** * The index '1' is the schema name */ PHALCON_OBS_VAR(schema_name); phalcon_array_fetch_long(&schema_name, table, 1, PH_NOISY); if (Z_TYPE_P(schema_name) != IS_NULL) { if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_VAR(sql_schema); PHALCON_CONCAT_VVVSV(sql_schema, escape_char, schema_name, escape_char, ".", sql_table); } else { PHALCON_INIT_NVAR(sql_schema); PHALCON_CONCAT_VSV(sql_schema, schema_name, ".", sql_table); } } else { PHALCON_CPY_WRT(sql_schema, sql_table); } /** * The index '2' is the table alias */ if (phalcon_array_isset_long(table, 2)) { PHALCON_OBS_VAR(alias_name); phalcon_array_fetch_long(&alias_name, table, 2, PH_NOISY); if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_VAR(sql_table_alias); PHALCON_CONCAT_VSVVV(sql_table_alias, sql_schema, " ", escape_char, alias_name, escape_char); } else { PHALCON_INIT_NVAR(sql_table_alias); PHALCON_CONCAT_VSV(sql_table_alias, sql_schema, " ", alias_name); } } else { PHALCON_CPY_WRT(sql_table_alias, sql_schema); } RETURN_CTOR(sql_table_alias); } if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_NVAR(sql_table); PHALCON_CONCAT_VVV(sql_table, escape_char, table, escape_char); RETURN_CTOR(sql_table); } RETURN_CTOR(table); }
/** * Gets the a value to validate in the array/object data source * * @param string $attribute * @return mixed */ PHP_METHOD(Phalcon_Validation, getValue){ zval *attribute, *entity, *method, *value = NULL, *data, *values; zval *filters, *field_filters, *service_name; zval *dependency_injector = NULL, *filter_service; zval *filtered; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &attribute); PHALCON_OBS_VAR(entity); phalcon_read_property_this(&entity, this_ptr, SL("_entity"), PH_NOISY_CC); /** * If the entity is an object use it to retrieve the values */ if (Z_TYPE_P(entity) == IS_OBJECT) { PHALCON_INIT_VAR(method); PHALCON_CONCAT_SV(method, "get", attribute); if (phalcon_method_exists(entity, method TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(value); phalcon_call_method_zval(value, entity, method); } else { if (phalcon_method_exists_ex(entity, SS("readattribute") TSRMLS_CC) == SUCCESS) { PHALCON_INIT_NVAR(value); phalcon_call_method(value, entity, "readattribute"); } else { if (phalcon_isset_property_zval(entity, attribute TSRMLS_CC)) { PHALCON_OBS_NVAR(value); phalcon_read_property_zval(&value, entity, attribute, PH_NOISY_CC); } else { PHALCON_INIT_NVAR(value); } } } RETURN_CCTOR(value); } PHALCON_OBS_VAR(data); phalcon_read_property_this(&data, this_ptr, SL("_data"), PH_NOISY_CC); if (Z_TYPE_P(data) != IS_ARRAY) { if (Z_TYPE_P(data) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "There is no data to validate"); return; } } /** * Check if there is a calculated value */ PHALCON_OBS_VAR(values); phalcon_read_property_this(&values, this_ptr, SL("_values"), PH_NOISY_CC); if (phalcon_array_isset(values, attribute)) { PHALCON_OBS_NVAR(value); phalcon_array_fetch(&value, values, attribute, PH_NOISY_CC); RETURN_CCTOR(value); } PHALCON_INIT_NVAR(value); if (Z_TYPE_P(data) == IS_ARRAY) { if (phalcon_array_isset(data, attribute)) { PHALCON_OBS_NVAR(value); phalcon_array_fetch(&value, data, attribute, PH_NOISY_CC); } } else { if (Z_TYPE_P(data) == IS_OBJECT) { if (phalcon_isset_property_zval(data, attribute TSRMLS_CC)) { PHALCON_OBS_NVAR(value); phalcon_read_property_zval(&value, data, attribute, PH_NOISY_CC); } } } if (Z_TYPE_P(value) != IS_NULL) { PHALCON_OBS_VAR(filters); phalcon_read_property_this(&filters, this_ptr, SL("_filters"), PH_NOISY_CC); if (Z_TYPE_P(filters) == IS_ARRAY) { if (phalcon_array_isset(filters, attribute)) { PHALCON_OBS_VAR(field_filters); phalcon_array_fetch(&field_filters, filters, attribute, PH_NOISY_CC); if (zend_is_true(field_filters)) { PHALCON_INIT_VAR(service_name); ZVAL_STRING(service_name, "filter", 1); PHALCON_INIT_VAR(dependency_injector); phalcon_call_method(dependency_injector, this_ptr, "getdi"); 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_validation_exception_ce, "A dependency injector is required to obtain the 'filter' service"); return; } } PHALCON_INIT_VAR(filter_service); phalcon_call_method_p1(filter_service, dependency_injector, "getshared", service_name); if (Z_TYPE_P(filter_service) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "Returned 'filter' service is invalid"); return; } PHALCON_INIT_VAR(filtered); phalcon_call_method_p2(filtered, filter_service, "sanitize", value, field_filters); RETURN_CCTOR(filtered); } } } /** * Cache the calculated value */ phalcon_update_property_array(this_ptr, SL("_values"), attribute, value TSRMLS_CC); RETURN_CCTOR(value); } RETURN_MM_NULL(); }
/** * Validate a set of data according to a set of rules * * @param array|object $data * @param object $entity * @return Phalcon\Validation\Message\Group */ PHP_METHOD(Phalcon_Validation, validate){ zval *data = NULL, *entity = NULL, *validators, *messages = NULL, *status = NULL; zval *cancel_on_fail, *scope = NULL, *attribute = NULL, *validator = NULL; zval *must_cancel = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 2, &data, &entity); if (!data) { PHALCON_INIT_VAR(data); } if (!entity) { PHALCON_INIT_VAR(entity); } PHALCON_OBS_VAR(validators); phalcon_read_property_this(&validators, this_ptr, SL("_validators"), PH_NOISY_CC); if (Z_TYPE_P(validators) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "There are no validators to validate"); return; } /** * Clear pre-calculated values */ phalcon_update_property_null(this_ptr, SL("_values") TSRMLS_CC); /** * Implicitly creates a Phalcon\Validation\Message\Group object */ PHALCON_INIT_VAR(messages); object_init_ex(messages, phalcon_validation_message_group_ce); phalcon_call_method_noret(messages, "__construct"); /** * Validation classes can implement the 'beforeValidation' callback */ if (phalcon_method_exists_ex(this_ptr, SS("beforevalidation") TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(status); phalcon_call_method_p3(status, this_ptr, "beforevalidation", data, entity, messages); if (PHALCON_IS_FALSE(status)) { RETURN_CCTOR(status); } } phalcon_update_property_this(this_ptr, SL("_messages"), messages TSRMLS_CC); if (Z_TYPE_P(data) == IS_ARRAY) { phalcon_update_property_this(this_ptr, SL("_data"), data TSRMLS_CC); } else { if (Z_TYPE_P(data) == IS_OBJECT) { phalcon_update_property_this(this_ptr, SL("_data"), data TSRMLS_CC); } } PHALCON_INIT_VAR(cancel_on_fail); ZVAL_STRING(cancel_on_fail, "cancelOnFail", 1); phalcon_is_iterable(validators, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(scope); if (Z_TYPE_P(scope) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "The validator scope is not valid"); return; } PHALCON_OBS_NVAR(attribute); phalcon_array_fetch_long(&attribute, scope, 0, PH_NOISY_CC); PHALCON_OBS_NVAR(validator); phalcon_array_fetch_long(&validator, scope, 1, PH_NOISY_CC); if (Z_TYPE_P(validator) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "One of the validators is not valid"); return; } PHALCON_INIT_NVAR(status); phalcon_call_method_p2(status, validator, "validate", this_ptr, attribute); /** * Check if the validation must be canceled if this validator fails */ if (PHALCON_IS_FALSE(status)) { PHALCON_INIT_NVAR(must_cancel); phalcon_call_method_p1(must_cancel, validator, "getoption", cancel_on_fail); if (zend_is_true(must_cancel)) { break; } } zend_hash_move_forward_ex(ah0, &hp0); } /** * Get the messages generated by the validators */ PHALCON_OBS_NVAR(messages); phalcon_read_property_this(&messages, this_ptr, SL("_messages"), PH_NOISY_CC); if (phalcon_method_exists_ex(this_ptr, SS("aftervalidation") TSRMLS_CC) == SUCCESS) { phalcon_call_method_p3_noret(this_ptr, "aftervalidation", data, entity, messages); } RETURN_CCTOR(messages); }
/** * Executes the validation * * @param Phalcon\Validation $validator * @param string $attribute * @return boolean */ PHP_METHOD(Phalcon_Validation_Validator_Between, validate){ zval *validator, *attribute, *value = NULL, *allow_empty, *minimum, *maximum, *label; zval *pairs, *valid = NULL, *message_str, *prepared = NULL, *message, *code; zend_class_entry *ce = Z_OBJCE_P(getThis()); PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &validator, &attribute); PHALCON_VERIFY_CLASS_EX(validator, phalcon_validation_ce, phalcon_validation_exception_ce, 1); PHALCON_CALL_METHOD(&value, validator, "getvalue", attribute); PHALCON_OBS_VAR(allow_empty); RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &allow_empty, getThis(), phalcon_interned_allowEmpty TSRMLS_CC)); if (zend_is_true(allow_empty) && phalcon_validation_validator_isempty_helper(value)) { RETURN_MM_TRUE; } PHALCON_OBS_VAR(minimum); RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &minimum, getThis(), "minimum" TSRMLS_CC)); PHALCON_OBS_VAR(maximum); RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &maximum, getThis(), "maximum" TSRMLS_CC)); PHALCON_CALL_SELF(&valid, "valid", value, minimum, maximum); if (PHALCON_IS_FALSE(valid)) { PHALCON_OBS_VAR(label); RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &label, getThis(), phalcon_interned_label TSRMLS_CC)); if (!zend_is_true(label)) { PHALCON_CALL_METHOD(&label, validator, "getlabel", attribute); if (!zend_is_true(label)) { PHALCON_CPY_WRT(label, attribute); } } PHALCON_ALLOC_GHOST_ZVAL(pairs); array_init_size(pairs, 3); Z_ADDREF_P(label); add_assoc_zval_ex(pairs, SS(":field"), label); Z_ADDREF_P(minimum); add_assoc_zval_ex(pairs, SS(":min"), minimum); Z_ADDREF_P(maximum); add_assoc_zval_ex(pairs, SS(":max"), maximum); PHALCON_OBS_VAR(message_str); RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &message_str, getThis(), phalcon_interned_message TSRMLS_CC)); if (!zend_is_true(message_str)) { PHALCON_OBSERVE_OR_NULLIFY_VAR(message_str); RETURN_MM_ON_FAILURE(phalcon_validation_getdefaultmessage_helper(Z_OBJCE_P(validator), &message_str, validator, "Between" TSRMLS_CC)); } PHALCON_OBS_VAR(code); RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &code, getThis(), phalcon_interned_code TSRMLS_CC)); if (Z_TYPE_P(code) == IS_NULL) { ZVAL_LONG(code, 0); } PHALCON_CALL_FUNCTION(&prepared, "strtr", message_str, pairs); message = phalcon_validation_message_construct_helper(prepared, attribute, "Between", code TSRMLS_CC); Z_DELREF_P(message); PHALCON_CALL_METHOD(NULL, validator, "appendmessage", message); RETURN_MM_FALSE; } RETURN_MM_TRUE; }
/** * Changes internal pointer to a specific position in the resultset * * @param int $position */ PHP_METHOD(Phalcon_Mvc_Model_Resultset, seek){ long i; zval *type, *result, *rows, *position; zval *pointer, *is_different; HashTable *ah0; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &position) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_OBS_VAR(pointer); phalcon_read_property(&pointer, this_ptr, SL("_pointer"), PH_NOISY_CC); /** * We only seek the records if the current position is diferent than the passed one */ PHALCON_INIT_VAR(is_different); is_not_equal_function(is_different, pointer, position TSRMLS_CC); if (PHALCON_IS_TRUE(is_different)) { PHALCON_OBS_VAR(type); phalcon_read_property(&type, this_ptr, SL("_type"), PH_NOISY_CC); if (zend_is_true(type)) { /** * Here, the resultset is fetched one by one because is large */ PHALCON_OBS_VAR(result); phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC); phalcon_call_method_p1_noret(result, "dataseek", position); } else { /** * Here, the resultset is a small array */ PHALCON_OBS_VAR(rows); phalcon_read_property(&rows, this_ptr, SL("_rows"), PH_NOISY_CC); /** * We need to fetch the records because rows is null */ if (Z_TYPE_P(rows) == IS_NULL) { PHALCON_OBS_VAR(result); phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC); if (PHALCON_IS_NOT_FALSE(result)) { PHALCON_INIT_NVAR(rows); phalcon_call_method(rows, result, "fetchall"); phalcon_update_property_zval(this_ptr, SL("_rows"), rows TSRMLS_CC); } } convert_to_long(position); if(Z_TYPE_P(rows) == IS_ARRAY){ ah0 = Z_ARRVAL_P(rows); zend_hash_internal_pointer_reset(ah0); i = 0; while (1) { if (i >= Z_LVAL_P(position)) { break; } zend_hash_move_forward(ah0); i++; } } phalcon_update_property_zval(this_ptr, SL("_pointer"), position TSRMLS_CC); } } PHALCON_MM_RESTORE();}